chaffjs 0.30.0 → 0.32.0

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

@@ -66,6 +66,8 @@ export type LexiconEntry = {
   readonly rewrite?: string | undefined;
   /** 語の組の名前。同じ組の語どうしだけを比べる rule が使う（対応する OS を言う語と、対応する言語を言う語を分ける）。 */
   readonly group?: string | undefined;
+  /** 元号の元年の西暦の年（令和は 2019）。元号で書いた年を西暦の年にする rule が使う。 */
+  readonly first_year?: number | undefined;
   /** pattern を adapter が語に分けたもの。品詞が読めるときだけ core が入れる。語彙表を書く側は書かない。 */
   readonly tokens?: readonly Token[] | undefined;
 };
@@ -277,6 +279,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/product-names.ts

@@ -0,0 +1,98 @@
+import { escapeRegExp } from "./orthography.ts";
+
+// 製品の名前を、文書の中で二通りに書いた所（ミナモール錠 と ミナモル錠）。製品の名前は、製品の形を言う語（錠、カプセル、クリーム）の
+// すぐ前の、カタカナの連なり。形の語は語彙表 product-form が言い、group が同じ語は同じ形の別の書き方。作った製品の名前は解析器が
+// 固有名詞と読まず、読みも名前の字のとおりにずれるので、人や会社の名前の見方では比べられない。
+
+export type ProductForm = { readonly pattern: string; readonly group: string };
+
+/** surface は形の語も含めた書いたまま。base はカタカナの名前の部分、form は形の語の組。 */
+export type ProductMention = { readonly surface: string; readonly offset: number; readonly base: string; readonly form: string };
+
+export type ProductVariant = { readonly mention: ProductMention; readonly usual: string; readonly kind: "near" };
+
+const KATAKANA = /[\p{Script=Katakana}ー]/u;
+/** 形の語の後ろに続くと、長い語の一部になる字（錠剤、液晶、ゲルマニウム、スプレー缶）。 */
+const WORD_CONTINUES = /[\p{Script=Han}\p{Script=Katakana}ー]/u;
+/** 名前の部分の字の数の下限。短いカタカナ（ケア、ハーブ）は製品の名前でなく、ふつうの語のことが多い。 */
+const MIN_NAME_CHARS = 4;
+/** 名前を探す、形の語の前の範囲（UTF-16 の単位）。 */
+const LOOKBACK = 30;
+const LONG_VOWEL = "ー";
+
+/** at のすぐ前の、カタカナの連なり。 */
+const katakanaBefore = (source: string, at: number): string => {
+  const chars = Array.from(source.slice(Math.max(0, at - LOOKBACK), at));
+  return chars.slice(chars.findLastIndex((char) => !KATAKANA.test(char)) + 1).join("");
+};
+
+const mentionAt = (source: string, form: ProductForm, at: number): ProductMention | undefined => {
+  const end = at + form.pattern.length;
+  if (WORD_CONTINUES.test(source.charAt(end))) return undefined;
+  const base = katakanaBefore(source, at);
+  if (Array.from(base).length < MIN_NAME_CHARS) return undefined;
+  return { surface: source.slice(at - base.length, end), offset: at - base.length, base, form: form.group };
+};
+
+/** 文書の中の製品の名前の現れ。同じ所で終わる形の語は長いほうを取る（顆粒 と 粒）。 */
+export const productMentionsIn = (source: string, forms: readonly ProductForm[]): ProductMention[] => {
+  const ends = new Set<number>();
+  return forms
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((form) =>
+      [...source.matchAll(new RegExp(escapeRegExp(form.pattern), "gu"))].flatMap((match) => {
+        const end = match.index + form.pattern.length;
+        if (ends.has(end)) return [];
+        const mention = mentionAt(source, form, match.index);
+        if (mention !== undefined) ends.add(end);
+        return mention === undefined ? [] : [mention];
+      }),
+    )
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+/** 同じ長さで、一字だけ違う（ミナモール と ミナモオル）。 */
+const isOneReplaced = (left: readonly string[], right: readonly string[]): boolean =>
+  left.length === right.length && left.filter((char, index) => char !== right[index]).length === 1;
+
+/** longer から長音の記号を一つ抜くと shorter になる（ミナモール と ミナモル）。 */
+const dropsOneLongVowel = (longer: readonly string[], shorter: readonly string[]): boolean =>
+  longer.length === shorter.length + 1 && longer.some((char, index) => char === LONG_VOWEL && longer.toSpliced(index, 1).join("") === shorter.join(""));
+
+/** 二つのカタカナの名前が、一字の置き換えか、長音の記号一つの有る無しだけ違う。 */
+export const isKanaSlip = (left: string, right: string): boolean => {
+  const [leftChars, rightChars] = [Array.from(left), Array.from(right)];
+  return isOneReplaced(leftChars, rightChars) || dropsOneLongVowel(leftChars, rightChars) || dropsOneLongVowel(rightChars, leftChars);
+};
+
+type Counted = { readonly mention: ProductMention; readonly count: number };
+
+/**
+ * slip が usual の書き損じと言えるか。形の語の組が同じで、名前の部分が一字違いか長音の有る無しで、slip が一度だけ、usual が二度以上。
+ * 一字違いの別の製品もあるので、何度も書いた名前と一度だけの名前の組に限る。
+ */
+export const isProductSlip = (slip: Counted, usual: Counted): boolean =>
+  slip.count === 1 && usual.count >= 2 && slip.mention.form === usual.mention.form && isKanaSlip(slip.mention.base, usual.mention.base);
+
+/** 名前と形の語の組ごとに数える。同じ組の別の書き方（錠 と 錠剤）は同じ製品の現れ。 */
+const talliesOf = (mentions: readonly ProductMention[]): Counted[] => {
+  const tallies = new Map<string, Counted>();
+  mentions.forEach((mention) => {
+    const key = `${mention.base}\u0000${mention.form}`;
+    const tally = tallies.get(key);
+    tallies.set(key, { mention: tally?.mention ?? mention, count: (tally?.count ?? 0) + 1 });
+  });
+  return [...tallies.values()];
+};
+
+/** 多いほうが先。同数なら先に書いたほう。 */
+const byUsage = (left: Counted, right: Counted): number => right.count - left.count || left.mention.offset - right.mention.offset;
+
+/** 製品の名前の、一度だけ書いた書き損じ。相手のうち一番多いものと比べる。 */
+export const productVariants = (mentions: readonly ProductMention[]): ProductVariant[] => {
+  const tallies = talliesOf(mentions);
+  return tallies.flatMap((tally): ProductVariant[] => {
+    const [usual] = tallies.filter((other) => isProductSlip(tally, other)).toSorted(byUsage);
+    return usual === undefined ? [] : [{ mention: tally.mention, usual: usual.mention.surface, kind: "near" }];
+  });
+};

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/reference-numbers.ts

@@ -0,0 +1,55 @@
+// A document's own reference number (a booking or confirmation number) written two ways: the same letters and digits with
+// two neighbours swapped (MN-48215 and MN-48251), both right after a label of the same kind. Pure: reads the document's text;
+// the labels (予約番号, Booking number) come from the language's reference-label lexicon, grouped by what they label.
+import type { LexiconEntry } from "./plugin.ts";
+import { labelBefore, swappedVariants, withoutUrls } from "./phone-numbers.ts";
+
+/** A reference number as written, where it is, its letters and digits without separators, and its label's group. */
+export type ReferenceNumber = { readonly offset: number; readonly written: string; readonly characters: string; readonly label: string };
+
+/** A reference number that is another of the same label with two neighbours swapped, and that other number. */
+export type ReferenceVariant = { readonly number: ReferenceNumber; readonly other: ReferenceNumber };
+
+/** Letters and digits, half or full width, joined by hyphens (MN-48215, AR730514, ＭＮ－４８２１５). */
+export const REFERENCE_SHAPE = /(?<![A-Za-z0-9Ａ-Ｚａ-ｚ０-９\-‐−－])[A-Za-z0-9Ａ-Ｚａ-ｚ０-９]+(?:[-‐−－][A-Za-z0-9Ａ-Ｚａ-ｚ０-９]+)*/gu;
+/** Digits enough that a swap is a slip in one number, not two short codes (A-12, B-21). */
+export const MIN_DIGITS = 4;
+export const MAX_CHARACTERS = 24;
+const DIGIT = /\d/gu;
+const SEPARATOR = /[-‐−－]/gu;
+/** Only spaces and a colon, comma or opening bracket between the label and its number (「予約番号：」, "booking number, "); not a sentence's end. */
+const LABEL_TO_NUMBER = /^[\s:：,，、#＃(（「『[［]{0,4}$/u;
+
+export const charactersOf = (written: string): string => written.normalize("NFKC").replaceAll(SEPARATOR, "").replaceAll(" ", "").toUpperCase();
+
+/** A first group a number in groups may open with: capitals and digits only (HM, 5520), not a word (No, Member). */
+const OPENING_GROUP = /^[0-9A-Z０-９Ａ-Ｚ]+$/u;
+/** One space, then four or more capitals and digits holding a digit, not run on into a word (8137 の; not 100 copies, 080, 2名, 2nd). */
+const FOLLOWING_GROUP = /^ (?=[0-9A-Z０-９Ａ-Ｚ]*[0-9０-９])[0-9A-Z０-９Ａ-Ｚ]{4,}(?![\p{L}\p{N}\-‐−－](?<!\p{Script=Hiragana}))/u;
+
+/** The groups after a number's first, written one space apart on its line (HM 5520 8137); none when the first is not a group. Reading stops once past the longest number, so a run-on is still too long. */
+export const followingGroups = (text: string, end: number, first: string): string => {
+  if (!OPENING_GROUP.test(first)) return "";
+  const read = (at: number, sofar: string): string => {
+    const tooLong = charactersOf(first + sofar).length > MAX_CHARACTERS;
+    const group = tooLong ? undefined : FOLLOWING_GROUP.exec(text.slice(at, at + MAX_CHARACTERS + 1))?.[0];
+    return group === undefined ? sofar : read(at + group.length, sofar + group);
+  };
+  return read(end, "");
+};
+
+/** The reference numbers of a text written right after a label on their line; unlabelled codes and URLs are not read. */
+export const labelledReferenceNumbers = (source: string, labels: readonly LexiconEntry[]): ReferenceNumber[] => {
+  const text = withoutUrls(source);
+  return [...text.matchAll(REFERENCE_SHAPE)].flatMap((match) => {
+    const written = match[0] + followingGroups(text, match.index + match[0].length, match[0]);
+    const characters = charactersOf(written);
+    if ((characters.match(DIGIT)?.length ?? 0) < MIN_DIGITS || characters.length > MAX_CHARACTERS) return [];
+    const label = labelBefore(text, match.index, labels);
+    if (label === undefined || !LABEL_TO_NUMBER.test(label.between)) return [];
+    return [{ offset: match.index, written, characters, label: label.group }];
+  });
+};
+
+/** Every writing of a reference number that is another of the same label with two neighbours swapped (swappedVariants). */
+export const referenceVariants = (numbers: readonly ReferenceNumber[]): ReferenceVariant[] => swappedVariants(numbers, (number) => number.characters);

package/src/spaced-person-name.ts

@@ -0,0 +1,97 @@
+import type { Span } from "./plugin.ts";
+import { isInPersonField as isFieldValue } from "./person-field.ts";
+
+// 空白を挟んで書いた姓と名（高瀬 誠、佐伯 未咲）を、解析器の品詞に頼らず、前後の語で人の名前と読む。解析器は姓を地名やふつうの
+// 名詞と読み、名を二語に切ることがあるので、姓と名を一つの名前にできない。後ろに敬称か肩書き（様、部長）が付くか、人を書く欄
+// （氏名：、承認者：）の行の終わりにあれば、人の名前と読む。欄に書いた名と同じ名を空白の後ろに書いたもの（受託者：西村 亮 の
+// 文書の 西邑 亮が）も、人の名前と読む。
+
+/** suffixes は敬称（様、さん）、titles は名前のすぐ後ろの肩書き（部長）、labels は人を書く欄の語（氏名、承認者）。語彙表から。 */
+export type SpacedNameCues = { readonly suffixes: readonly string[]; readonly titles: readonly string[]; readonly labels: readonly string[] };
+
+export type SpacedName = { readonly surname: Span; readonly given: Span };
+
+/** 姓と名それぞれの字数の上限。長い漢字の連なり（営業部長）は姓でない。 */
+const MAX_PART = 3;
+/** 姓の前を読む範囲（UTF-16 の単位）。姓より長い漢字の連なりを、長いまま見るため。 */
+const LOOKBACK = 12;
+const NAME_SPACE = /[\u0020\u3000]/gu;
+const HAN = /^\p{Script=Han}$/u;
+const LEADING_HAN = /^\p{Script=Han}+/u;
+/** 文字列の頭と終わりの一字（𠮷 は UTF-16 の二つで一字）。 */
+const FIRST_LETTER = /^./u;
+const LAST_LETTER = /.$/u;
+const ONE_SPACE = /^[\u0020\u3000]/u;
+/** 欄の語と名前のあいだに置かない記号。文の中の「：」の後ろは欄ではない。 */
+const NOT_IN_FIELD = /[。、，,：:]/u;
+const FIELD_COLON = /[：:]/u;
+/** 欄の行の頭の、Markdown の印（箇条書き、引用、見出し）。 */
+const LINE_MARKS = /^[\s>*#+-]*/u;
+/** 欄の名前の後ろ: 行の終わり。日付などの括弧一つで行が終わってもよい（髙瀬 誠（2026年4月1日））。 */
+const FIELD_END = /^[\u0020\u3000]*(?:[（(][^（()）\n]*[）)][\u0020\u3000]*)?(?:\r?\n|$)/u;
+
+const isHan = (letter: string | undefined): boolean => letter !== undefined && HAN.test(letter);
+
+/** 人を書く欄の行（承認者：営業部長 高瀬 誠）で、姓が欄の語の後ろにあるか。 */
+const isInPersonField = (source: string, surnameStart: number, labels: readonly string[]): boolean => {
+  const head = source.slice(source.lastIndexOf("\n", surnameStart - 1) + 1, surnameStart);
+  const colon = head.search(FIELD_COLON);
+  if (colon < 0 || NOT_IN_FIELD.test(head.slice(colon + 1))) return false;
+  const label = head.slice(0, colon).replace(LINE_MARKS, "").trimEnd();
+  return labels.some((word) => label.endsWith(word));
+};
+
+/** 空白の後ろの漢字の連なりの頭から、敬称か肩書きの前までを名と読む（誠部長 の 誠、健太 様 の 健太）。 */
+const givenBeforeSuffix = (run: string, after: string, words: readonly string[]): string | undefined => {
+  const letters = [...run];
+  return letters
+    .slice(0, MAX_PART)
+    .map((_letter, index) => letters.slice(0, index + 1).join(""))
+    .find((given) => {
+      const rest = given.length === run.length ? after.replace(ONE_SPACE, "") : run.slice(given.length) + after;
+      return words.some((word) => rest.startsWith(word));
+    });
+};
+
+/** fieldGivens は、文書が人を書く欄に書いた名（亮）。その名と同じ漢字の連なりは、敬称が無くても名と読む。 */
+const givenAt = (source: string, start: number, cues: SpacedNameCues, inField: boolean, fieldGivens: ReadonlySet<string>): string | undefined => {
+  const run = LEADING_HAN.exec(source.slice(start, start + LOOKBACK))?.[0];
+  if (run === undefined) return undefined;
+  const after = source.slice(start + run.length, start + run.length + LOOKBACK);
+  const suffixed = givenBeforeSuffix(run, after, [...cues.suffixes, ...cues.titles]);
+  if (suffixed !== undefined) return suffixed;
+  if (fieldGivens.has(run)) return run;
+  return inField && [...run].length <= MAX_PART && FIELD_END.test(after) ? run : undefined;
+};
+
+/** 空白の前の漢字の連なり。字数が姓の形で、肩書きや敬称で終わらない（部長 高瀬様 の 部長 は姓でない）。 */
+const surnameBefore = (source: string, space: number, cues: SpacedNameCues): string | undefined => {
+  const window = source.slice(Math.max(0, space - LOOKBACK), space);
+  const letters = [...window];
+  const run = letters.slice(letters.findLastIndex((letter) => !isHan(letter)) + 1).join("");
+  if (run === "" || [...run].length > MAX_PART) return undefined;
+  return [...cues.titles, ...cues.suffixes].some((word) => run.endsWith(word)) ? undefined : run;
+};
+
+const namesIn = (source: string, cues: SpacedNameCues, fieldGivens: ReadonlySet<string>): SpacedName[] =>
+  [...source.matchAll(NAME_SPACE)].flatMap((match) => {
+    const space = match.index;
+    if (!isHan(LAST_LETTER.exec(source.slice(Math.max(0, space - 2), space))?.[0]) || !isHan(FIRST_LETTER.exec(source.slice(space + 1, space + 3))?.[0]))
+      return [];
+    const surname = surnameBefore(source, space, cues);
+    if (surname === undefined) return [];
+    const surnameStart = space - surname.length;
+    const given = givenAt(source, space + 1, cues, isInPersonField(source, surnameStart, cues.labels), fieldGivens);
+    return given === undefined ? [] : [{ surname: { start: surnameStart, end: space }, given: { start: space + 1, end: space + 1 + given.length } }];
+  });
+
+/**
+ * 空白を挟んだ姓と名で、後ろに敬称か肩書きが付くか、人を書く欄の行の終わりにあるもの。欄に書いた名と同じ名を書いたもの
+ * （受託者：西村 亮 と 西邑 亮が）も。
+ */
+export const spacedPersonNamesIn = (source: string, cues: SpacedNameCues): SpacedName[] => {
+  const fields = namesIn(source, cues, new Set()).filter(({ surname, given }) =>
+    isFieldValue(source, surname.start, given.end - surname.start, cues.labels, cues.suffixes),
+  );
+  return namesIn(source, cues, new Set(fields.map(({ given }) => source.slice(given.start, given.end))));
+};

package/src/spacing-code.ts

@@ -0,0 +1,47 @@
+import type { Span } from "./plugin.ts";
+import { HYPHEN_CHARS } from "./orthography.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, an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it, and an
+// identifier such as a booking or model number (MN-48215, SB-210), which a space sets off from the sentence. 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);
+
+/**
+ * An identifier: letters and digits joined by hyphens with three digits or more in a row (MN-48215, SB-210, KM-SP300), or
+ * capitals followed by four digits or more (A1234567). A shorter name with a digit (EC2, H30, UTF-8, COVID-19) is a word
+ * the writer spaces like any other.
+ */
+// The hyphen may be full-width or Japanese (KM－SP300), as in the hyphenated numbers orthography.ts reads.
+const HYPHENATED = new RegExp(
+  `(?<![A-Za-z0-9.${HYPHEN_CHARS}])[A-Za-z0-9]+(?:[${HYPHEN_CHARS}][A-Za-z0-9]+)+(?![A-Za-z0-9${HYPHEN_CHARS}]|\\.[A-Za-z0-9])`,
+  "gu",
+);
+const CAPITALS_SERIAL = new RegExp(`(?<![A-Za-z0-9.${HYPHEN_CHARS}])[A-Z]+\\d{4,}(?![A-Za-z0-9${HYPHEN_CHARS}]|\\.[A-Za-z0-9])`, "gu");
+const HAS_LETTER = /[A-Za-z]/u;
+const SERIAL_DIGITS = /\d{3}/u;
+
+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)));
+
+const isIdentifier = (word: string): boolean => HAS_LETTER.test(word) && SERIAL_DIGITS.test(word);
+
+export const identifierSpans = (text: string): Span[] =>
+  [...spansOf(text, HYPHENATED), ...spansOf(text, CAPITALS_SERIAL)].filter((span) => isIdentifier(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 };