chaffjs 0.31.0 → 0.32.0

package/src/person-full-name.ts

@@ -0,0 +1,70 @@
+import type { NameCue } from "./name-cue.ts";
+import type { NameMention } from "./name-variants.ts";
+import type { Span, Token } from "./plugin.ts";
+import { isFollowedBySuffix } from "./name-person.ts";
+
+// 空白（半角か全角）を挟んで書いた姓と名（田中 裕子）。解析器は空白で名前を切るので、名だけ（裕子）が名前の現れになり、別の人の
+// 名（鈴木 祐子 の 祐子）と比べてしまう。姓と名を一つの現れにして、名前まるごとで比べる。
+
+/** 姓と名のあいだの空白（半角、全角）。 */
+const NAME_SPACE = /^[ \u3000]$/u;
+
+const nameTypeOf = (token: Token | undefined): string | undefined => (token?.pos === "PROPN" ? token.features?.["NameType"] : undefined);
+
+/** 姓の後ろの名。解析器が名（Giv）と読む語か、名を地名と読んでも（千尋 を Geo）後ろに敬称が付く、姓でない固有名詞。 */
+const isGivenName = (token: Token | undefined, tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const type = nameTypeOf(token);
+  return type === "Giv" || (token?.pos === "PROPN" && type !== "Sur" && isFollowedBySuffix(token, tokens, suffixes));
+};
+
+/** 姓と名を分ける空白の語。前の語を解析器が姓（Sur）と読み、後ろの語が名の、空白一つ。suffixes は敬称（様、さん）。 */
+export const fullNameGaps = (tokens: readonly Token[], suffixes: readonly string[] = []): Span[] =>
+  tokens.flatMap((token, index) =>
+    NAME_SPACE.test(token.surface) && nameTypeOf(tokens[index - 1]) === "Sur" && isGivenName(tokens[index + 1], tokens, suffixes) ? [token.span] : [],
+  );
+
+const CUE_STRENGTH: readonly (NameCue | undefined)[] = [undefined, "bare", "slot", "person"];
+
+/** 二つの現れの名前らしさの強いほう。前置き（担当の）は姓の前に、敬称（様）は名の後ろに付く。 */
+const strongerCue = (left: NameCue | undefined, right: NameCue | undefined): NameCue | undefined =>
+  CUE_STRENGTH.indexOf(left) >= CUE_STRENGTH.indexOf(right) ? left : right;
+
+const joined = (surname: NameMention, given: NameMention): NameMention => {
+  const cue = strongerCue(surname.cue, given.cue);
+  return {
+    ...surname,
+    surface: `${surname.surface} ${given.surface}`,
+    reading: surname.reading === undefined || given.reading === undefined ? undefined : surname.reading + given.reading,
+    words: [...surname.words, ...given.words],
+    person: surname.person === true || given.person === true,
+    ...(cue === undefined ? {} : { cue }),
+  };
+};
+
+/** 空白をちょうど挟む、一語の姓と名か。名は解析器が二語に切ることがある（健汰 を 健 と 汰）。 */
+const isPair = (surname: NameMention, given: NameMention, gaps: readonly Span[]): boolean =>
+  surname.words.length === 1 && gaps.some((gap) => gap.start === surname.offset + surname.surface.length && gap.end === given.offset);
+
+/** 空白を挟んだ一語の姓と名（田中 裕子）を、一つの名前の現れにする。名だけ、姓だけの現れはそのまま。 */
+export const joinFullNames = (mentions: readonly NameMention[], gaps: readonly Span[]): NameMention[] => {
+  const names: NameMention[] = [];
+  mentions
+    .toSorted((left, right) => left.offset - right.offset)
+    .forEach((mention) => {
+      const previous = names.at(-1);
+      if (previous !== undefined && isPair(previous, mention, gaps)) names.splice(-1, 1, joined(previous, mention));
+      else names.push(mention);
+    });
+  return names;
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const SPACE = /\s/u;
+const withoutSpaces = (surface: string): string => surface.replaceAll(/\s/gu, "");
+
+/**
+ * 日本語の名前の、姓と名のあいだに空白を置くかどうかだけが違う二つ（田中 裕子 と 田中裕子）。書き方の揺れとしては指さない。空白の
+ * 幅の違い（半角と全角）と、英字の名前の空白（Mac OS と MacOS）は書き方の違いなので、ここには入れない。
+ */
+export const spacedOnly = (left: string, right: string): boolean =>
+  !LATIN.test(left) && !LATIN.test(right) && SPACE.test(left) !== SPACE.test(right) && withoutSpaces(left) === withoutSpaces(right);

package/src/phone-numbers.ts

@@ -34,7 +34,8 @@ 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;
+/** A Latin label is a whole word among Latin letters only: 「FAX受付」 has no spaces between words. */
+const LETTER = /\p{Script=Latin}/u;
 /** How far before a number its label may end: 「電話でのお問合せは、」, "by phone, call". */
 const MAX_LABEL_GAP = 15;
 const URL = /\b(?:https?:\/\/|www\.)\S+/giu;
@@ -48,23 +49,50 @@ const lastPlace = (before: string, label: string): number => {
 };
 
 type LabelBefore = { readonly group: string; readonly between: string };
+type LabelHit = { readonly group: string; readonly at: number; readonly end: number };
 
-/** 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
+/** The label ending nearest the end of a line's text, the longest when two end together (携帯電話 over 電話). */
+const nearestLabel = (before: string, labels: readonly LexiconEntry[]): LabelHit | undefined =>
+  labels
     .map((entry) => {
       const at = lastPlace(before, entry.pattern);
       return { group: entry.group ?? entry.pattern, at, end: at + entry.pattern.length };
     })
     .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 === undefined ? undefined : { group: nearest.group, between: before.slice(nearest.end) };
+
+/** A desk's name (窓口, Recall Line) says where a number goes, not what it is: FAX受付窓口 and Fax line name fax numbers. */
+const DESK_GROUP = "desk";
+const DESK_DEFAULT_GROUP = "phone";
+const DIGIT = /\d/u;
+
+/** The kind a label right before a desk's name gives its number, with no digits between; a phone number when there is none. */
+const deskKind = (before: string, desk: LabelHit, labels: readonly LexiconEntry[]): string => {
+  const kinds = labels.filter((entry) => entry.group !== DESK_GROUP);
+  const kind = nearestLabel(before.slice(0, desk.at), kinds);
+  return kind === undefined || DIGIT.test(before.slice(kind.end, desk.at)) ? DESK_DEFAULT_GROUP : kind.group;
 };
 
+/** The label ending nearest before a number on its line, the kind of number it gives, and what lies between. */
+export 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 = nearestLabel(before, labels);
+  if (nearest === undefined) return undefined;
+  const between = before.slice(nearest.end);
+  if (nearest.group !== DESK_GROUP) return { group: nearest.group, between };
+  return ANY_LETTER.test(between) ? undefined : { group: deskKind(before, nearest, labels), between };
+};
+
+/** A word between a desk's name and the digits says they are something else: Support ticket, 窓口受付番号. */
+const ANY_LETTER = /\p{L}/u;
+const UNCLOSED_OPENING = /^[(（](?!.*[)）])/u;
+
+/** A number as quoted: the bracket the number is put in (窓口（0120-123-456）) is not part of it, an area code's is ((555) 123-4567). */
+const withoutUnclosedBracket = (written: string): string => written.replace(UNCLOSED_OPENING, "");
+
 /** URLs covered with spaces, so neither a path segment (/call/) nor an id in one is read. Offsets stay the same. */
-const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".repeat(url.length));
+export const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".repeat(url.length));
 
 /** 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[] => {
@@ -75,7 +103,9 @@ export const labelledPhoneNumbers = (source: string, labels: readonly LexiconEnt
     const label = labelBefore(text, match.index, labels);
     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 }];
+    const matched = match[0].trim();
+    const written = withoutUnclosedBracket(matched);
+    return [{ offset: match.index + matched.length - written.length, written, digits, label: label.group }];
   };
   return [
     ...[...text.matchAll(NUMBER_SHAPE)].flatMap((match) => read(match, false)),
@@ -83,7 +113,7 @@ export const labelledPhoneNumbers = (source: string, labels: readonly LexiconEnt
   ].toSorted((a, b) => a.offset - b.offset);
 };
 
-/** Whether two digit strings are the same but for one pair of neighbours swapped. */
+/** Whether two strings (digits, or a reference number's letters and digits) are the same but for one pair of neighbours swapped. */
 export const swapsNeighbours = (a: string, b: string): boolean => {
   if (a.length !== b.length || a === b) return false;
   const differ = [...a].flatMap((digit, index) => (digit === b[index] ? [] : [index]));
@@ -91,24 +121,27 @@ export const swapsNeighbours = (a: string, b: string): boolean => {
   return differ.length === 2 && first !== undefined && second === first + 1 && a[first] === b[second] && a[second] === b[first];
 };
 
-const keyOf = (number: PhoneNumber): string => `${number.label}\u0000${number.digits}`;
+/** A labelled writing compared with the others of its label: where it is and the label's group. */
+type LabelledWriting = { readonly offset: number; readonly label: string };
 
 /**
- * Every writing of a number that is another number of the same label with two neighbours swapped: of the two, the one
- * written fewer times, or the one first written later when both are written as often. Each comes with the other number.
+ * Every writing that is another writing of the same label with two neighbouring characters swapped (characters is what is
+ * compared): of the two, the one written fewer times, or the one first written later when both are written as often. Each
+ * comes with the other writing.
  */
-export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] => {
-  const writings = numbers.reduce((byKey, number) => byKey.set(keyOf(number), [...(byKey.get(keyOf(number)) ?? []), number]), new Map<string, PhoneNumber[]>());
-  const timesOf = (number: PhoneNumber): number => writings.get(keyOf(number))?.length ?? 0;
+export const swappedVariants = <T extends LabelledWriting>(writtenAll: readonly T[], characters: (writing: T) => string): { number: T; other: T }[] => {
+  const keyOf = (writing: T): string => `${writing.label}\u0000${characters(writing)}`;
+  const writings = writtenAll.reduce((byKey, writing) => byKey.set(keyOf(writing), [...(byKey.get(keyOf(writing)) ?? []), writing]), new Map<string, T[]>());
+  const timesOf = (writing: T): number => writings.get(keyOf(writing))?.length ?? 0;
   const firsts = [...writings.values()].flatMap((group) => group.slice(0, 1));
-  const minorityOf = (a: PhoneNumber, b: PhoneNumber): PhoneNumber => {
+  const minorityOf = (a: T, b: T): T => {
     if (timesOf(a) !== timesOf(b)) return timesOf(a) < timesOf(b) ? a : b;
     return a.offset > b.offset ? a : b;
   };
   return firsts
     .flatMap((first, index) =>
       firsts.slice(index + 1).flatMap((second) => {
-        if (first.label !== second.label || !swapsNeighbours(first.digits, second.digits)) return [];
+        if (first.label !== second.label || !swapsNeighbours(characters(first), characters(second))) return [];
         const minority = minorityOf(first, second);
         const other = minority === first ? second : first;
         return (writings.get(keyOf(minority)) ?? []).map((number) => ({ number, other }));
@@ -116,3 +149,6 @@ export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] =
     )
     .toSorted((a, b) => a.number.offset - b.number.offset);
 };
+
+/** Every phone number that is another of the same label with two neighbouring digits swapped (swappedVariants). */
+export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] => swappedVariants(numbers, (number) => number.digits);

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;
 };

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/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

@@ -1,7 +1,9 @@
 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, and an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it. Pure.
+// 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;
@@ -15,6 +17,20 @@ 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 }));
 
@@ -22,5 +38,10 @@ 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);