chaffjs 0.30.0 → 0.32.0

package/src/company-kana-spelling.ts

@@ -0,0 +1,105 @@
+import type { CompanyMention } from "./company-names.ts";
+import { toKatakana } from "./kana-spelling.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+// 会社の名前の漢字一字を、その読みのかなで書いた所（みどり野生命保険株式会社 と みどりの生命保険株式会社）。読みは品詞解析が言う。
+
+/** 名前の中の語。start と end は source の上の位置。reading はカタカナ。 */
+export type ReadWord = { readonly start: number; readonly end: number; readonly surface: string; readonly reading: string | undefined };
+
+/** 漢字の名前を、かなで書いた所。usual は多いほうの書き方。 */
+export type KanaSpelled = { readonly surface: string; readonly offset: number; readonly usual: string };
+
+const HAN = /^\p{Script=Han}$/u;
+const KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}ー]$/u;
+const KATAKANA = /[ァ-ヶ]/gu;
+const KATAKANA_TO_HIRAGANA = 0x60;
+/** かなで書いた所の外側に続くと、名前の続き（別の名前）になる字。 */
+const NAME_CHAR = /[\p{Script=Katakana}\p{Script=Han}\p{Script=Latin}\p{N}ー]/u;
+/** 多いほうの書き方の数。一度だけの名前は、どちらが正しいとも言えない。 */
+const MIN_USUAL_COUNT = 2;
+
+const toHiragana = (text: string): string => text.replace(KATAKANA, (char) => String.fromCodePoint((char.codePointAt(0) ?? 0) - KATAKANA_TO_HIRAGANA));
+
+/**
+ * かなと漢字一字の語（みどり野 ミドリノ、野 ノ）の、漢字の読みと、語の中の位置（UTF-16 の単位）。かなの部分が読みの頭と終わりに
+ * 合い、残りがあるときだけ。漢字二字以上の語（生命 セイメイ）は、どの字がどの音か分からないので読まない。
+ */
+export const kanjiReadingOf = (
+  surface: string,
+  reading: string | undefined,
+): { readonly index: number; readonly kanji: string; readonly reading: string } | undefined => {
+  const chars = [...surface];
+  const at = chars.findIndex((char) => HAN.test(char));
+  const kanji = chars[at];
+  if (reading === undefined || kanji === undefined || !chars.every((char, index) => index === at || KANA.test(char))) return undefined;
+  const [head, tail] = [toKatakana(chars.slice(0, at).join("")), toKatakana(chars.slice(at + 1).join(""))];
+  const read = toKatakana(reading);
+  if (read.length <= head.length + tail.length || !read.startsWith(head) || !read.endsWith(tail)) return undefined;
+  return { index: chars.slice(0, at).join("").length, kanji, reading: read.slice(head.length, read.length - tail.length) };
+};
+
+const baseStartOf = (mention: CompanyMention): number =>
+  mention.position === "after" ? mention.offset : mention.offset + mention.surface.length - mention.base.length;
+
+/** 会社の名前の、漢字一字をその読みのひらがなかカタカナで書いた形（みどりの生命保険株式会社、みどりノ生命保険株式会社）。 */
+export const kanaSpellingsOf = (mention: CompanyMention, words: readonly ReadWord[]): string[] => {
+  const baseStart = baseStartOf(mention);
+  const baseEnd = baseStart + mention.base.length;
+  return words
+    .filter((word) => word.start >= baseStart && word.end <= baseEnd)
+    .flatMap((word) => {
+      const read = kanjiReadingOf(word.surface, word.reading);
+      if (read === undefined) return [];
+      const at = word.start - mention.offset + read.index;
+      const [before, after] = [mention.surface.slice(0, at), mention.surface.slice(at + read.kanji.length)];
+      return [toHiragana(read.reading), read.reading].map((kana) => `${before}${kana}${after}`);
+    });
+};
+
+const HIRAGANA = /^\p{Script=Hiragana}$/u;
+const HIRAGANA_AFTER = /^\p{Script=Hiragana}+/u;
+/** 助詞を探す、前のひらがなの字数。語彙表の一番長い助詞より長い。 */
+const PARTICLE_LOOKBACK = 10;
+
+const hiraganaBefore = (source: string, at: number): string => {
+  const chars = Array.from(source.slice(Math.max(0, at - PARTICLE_LOOKBACK), at));
+  return chars.slice(chars.findLastIndex((char) => !HIRAGANA.test(char)) + 1).join("");
+};
+
+/**
+ * 名前の側に名前の字が続かない現れ。続けば、別の長い名前の一部（あおいみどりの生命保険）。ひらがなが続くときは、助詞（当社は、
+ * と、における）で切れるときだけ名前の外と見る。particles は語彙表 company-name-kana の particle。
+ */
+const standsAlone = (source: string, at: number, length: number, position: CompanyMention["position"], particles: readonly string[]): boolean => {
+  const neighbour = position === "after" ? source.charAt(at - 1) : source.charAt(at + length);
+  if (NAME_CHAR.test(neighbour)) return false;
+  const kana = position === "after" ? hiraganaBefore(source, at) : (HIRAGANA_AFTER.exec(source.slice(at + length))?.[0] ?? "");
+  if (kana === "") return true;
+  return particles.some((particle) => (position === "after" ? kana.endsWith(particle) : kana.startsWith(particle)));
+};
+
+const occurrencesOf = (source: string, text: string): number[] => [...source.matchAll(new RegExp(escapeRegExp(text), "gu"))].map((match) => match.index);
+
+/**
+ * 二度以上書いた会社の名前の漢字一字を、その読みのかなで書いた所が一度だけある所。名前のほかの所はそのまま同じもの。
+ * 語の読みは words が言う（品詞解析の語）。前後のひらがなを切る助詞は particles。
+ */
+export const kanaSpelledCompanies = (
+  source: string,
+  mentions: readonly CompanyMention[],
+  words: readonly ReadWord[],
+  particles: readonly string[],
+): KanaSpelled[] => {
+  const counts = new Map<string, number>();
+  mentions.forEach((mention) => counts.set(mention.surface, (counts.get(mention.surface) ?? 0) + 1));
+  const usuals = mentions.filter(
+    (mention, index) => (counts.get(mention.surface) ?? 0) >= MIN_USUAL_COUNT && mentions.findIndex((other) => other.surface === mention.surface) === index,
+  );
+  return usuals.flatMap((usual) =>
+    [...new Set(kanaSpellingsOf(usual, words))].flatMap((spelled) => {
+      const found = occurrencesOf(source, spelled).filter((at) => standsAlone(source, at, spelled.length, usual.position, particles));
+      return found.length === 1 && found[0] !== undefined ? [{ surface: spelled, offset: found[0], usual: usual.surface }] : [];
+    }),
+  );
+};

package/src/company-names.ts

@@ -5,7 +5,16 @@ import { escapeRegExp } from "./orthography.ts";
 // 会社の形の語（株式会社、Inc）は語彙表 company-form が言う。group が同じ語は同じ形（Inc と Incorporated、株式会社 と (株)）、
 // position は名前のどちら側に立つか（無ければどちらにも立つ）。名前の部分は、形の語のすぐ隣の、名前に使う字の連なり。
 
-export type CompanyForm = { readonly pattern: string; readonly group: string; readonly position?: "before" | "after" | undefined };
+/**
+ * foreign は、カタカナか英字の名前のすぐ後ろにだけ立つ形の語（サウスベイ・インポート社 の 社）。漢字の語の中（会社、本社）では形の語でない。
+ * words はこの語で始まる語（社員、社長）で、そこでは形の語と読まない。
+ */
+export type CompanyForm = {
+  readonly pattern: string;
+  readonly group: string;
+  readonly position?: "before" | "after" | undefined;
+  readonly foreign?: { readonly words: readonly string[] } | undefined;
+};
 
 /** surface は形の語も含めた書いたまま。base は名前の部分、form は形の組、position は形の語が名前のどちら側にあるか。 */
 export type CompanyMention = {
@@ -14,6 +23,8 @@ export type CompanyMention = {
   readonly base: string;
   readonly form: string;
   readonly position: "before" | "after";
+  /** カタカナか英字の名前のすぐ後ろにだけ立つ形の語（社）で書いたもの。 */
+  readonly foreign?: boolean | undefined;
 };
 
 /** 二つの書き方の違い。spelling は記号・幅・大小だけ、form は会社の形、position は形の語の側、near は名前の一字違い。 */
@@ -26,7 +37,7 @@ export type IsProper = (start: number, end: number) => boolean;
 
 const LATIN = /\p{Script=Latin}/u;
 const LETTER = /\p{L}/u;
-/** 漢字・かなの名前に使う字。ひらがなは名前の外（の、は、まで）。 */
+/** 漢字・かなの名前に使う字。ひらがなは名前の頭にだけ立つ（kanaHeadOf）。 */
 const CJK_NAME = /[\p{Script=Katakana}\p{Script=Han}\p{Script=Latin}\p{N}ー・&＆]/u;
 const NOT_HAN_LETTER = /(?!\p{Script=Han})\p{L}/u;
 /** 英字の名前の一語。大文字か数字で始まる。 */
@@ -65,17 +76,69 @@ const CJK_BEFORE = new RegExp(`${CJK_NAME.source}+$`, "u");
 const CJK_AFTER = new RegExp(`^${CJK_NAME.source}+`, "u");
 const SPACES: ReadonlySet<string> = new Set([" ", "\u3000"]);
 
+/**
+ * 名前の頭のひらがなを切り分ける語（語彙表 company-name-kana）。particles は前の語に続けて書く語（は、と、における）、openers は
+ * 句読点や行の頭に立つ語（また、なお）、ends は名前の頭の終わりに来ない字（の、る、て）。
+ */
+export type KanaStops = { readonly particles: readonly string[]; readonly openers: readonly string[]; readonly ends: readonly string[] };
+
+/** ひらがなの前に何があるか。word は語や閉じ括弧（当社はこもれび、）により）、form は会社の形の語（株式会社こもれび）、boundary は句読点や行の頭。 */
+export type KanaLead = "word" | "form" | "boundary";
+
+const MIN_KANA_HEAD_LENGTH = 2;
+
+const longestPrefix = (text: string, words: readonly string[]): string | undefined =>
+  words.filter((word) => text.startsWith(word)).toSorted((left, right) => right.length - left.length)[0];
+
+/**
+ * 漢字やカタカナの名前のすぐ前のひらがなのうち、名前の頭と読む所（はこもれび の こもれび）。語のすぐ後ろなら助詞で始まるときだけ、
+ * その後ろを読む。形の語のすぐ後ろなら助詞で始まらないときだけ。二字以上で、句読点の後に立つ語で始まらず、助詞や動詞の終わりの字で終わらないもの。
+ * 語彙表が無ければ（英語の文書）ひらがなは名前に入れない。
+ */
+export const kanaHeadOf = (kana: string, lead: KanaLead, stops: KanaStops): string | undefined => {
+  if (stops.particles.length === 0) return undefined;
+  const particle = longestPrefix(kana, stops.particles);
+  if ((lead === "word" && particle === undefined) || (lead === "form" && particle !== undefined)) return undefined;
+  const head = lead === "word" ? kana.slice(particle?.length ?? 0) : kana;
+  if ([...head].length < MIN_KANA_HEAD_LENGTH || longestPrefix(head, stops.openers) !== undefined) return undefined;
+  return stops.ends.some((end) => head.endsWith(end)) ? undefined : head;
+};
+
+/** ひらがなをその前の語に続けて読む字。閉じ括弧や数字の後ろのひらがなも助詞（）により、第3条の）。 */
+const GLUED = /[\p{L}\p{N}\p{Pe}\p{Pf}]/u;
+const HIRAGANA = /\p{Script=Hiragana}/u;
+const KANA_AFTER = /^\p{Script=Hiragana}+/u;
+
+/** end の前に続くひらがなの始まり。 */
+const kanaRunStart = (source: string, end: number): number => {
+  let start = end;
+  while (start > 0 && HIRAGANA.test(source.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** 名前の前に続くひらがなのうち、名前の頭と読む所を足した始まり。 */
+const withKanaHead = (source: string, start: number, stops: KanaStops): number => {
+  const kanaStart = kanaRunStart(source, start);
+  if (kanaStart === start) return start;
+  const lead = GLUED.test(source.charAt(kanaStart - 1)) ? "word" : "boundary";
+  return start - (kanaHeadOf(source.slice(kanaStart, start), lead, stops)?.length ?? 0);
+};
+
 /** 漢字・かなの名前: 形の語の隣の、名前に使う字の続き。形の語との間の空白一つは名前の外。 */
-const cjkBaseBefore = (source: string, end: number): Span | undefined => {
+const cjkBaseBefore = (source: string, end: number, stops: KanaStops): Span | undefined => {
   const stop = SPACES.has(source.charAt(end - 1)) ? end - 1 : end;
   const match = CJK_BEFORE.exec(source.slice(0, stop));
-  return match === null ? undefined : { start: match.index, end: stop };
+  return match === null ? undefined : { start: withKanaHead(source, match.index, stops), end: stop };
 };
 
-const cjkBaseAfter = (source: string, start: number): Span | undefined => {
+/** 形の語の後ろの名前。ひらがなで始まる名前（株式会社こもれび珈琲）は、ひらがなの後ろに名前に使う字が続くときだけ。 */
+const cjkBaseAfter = (source: string, start: number, stops: KanaStops): Span | undefined => {
   const from = SPACES.has(source.charAt(start)) ? start + 1 : start;
-  const match = CJK_AFTER.exec(source.slice(from));
-  return match === null ? undefined : { start: from, end: from + match[0].length };
+  const kana = KANA_AFTER.exec(source.slice(from))?.[0] ?? "";
+  const head = kana === "" ? "" : kanaHeadOf(kana, "form", stops);
+  if (head === undefined) return undefined;
+  const match = CJK_AFTER.exec(source.slice(from + head.length));
+  return match === null ? undefined : { start: from, end: from + head.length + match[0].length };
 };
 
 /** 名前の部分の字数。一字（法令の項目の印 イ、ロ）は名前と読まない。 */
@@ -94,22 +157,50 @@ const mentionOf = (source: string, base: Span, form: Span, group: string): Compa
   return { surface: source.slice(start, end), offset: start, base: source.slice(base.start, base.end), form: group, position };
 };
 
-const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper): Span | undefined =>
-  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at);
+/** カタカナか英字の名前の字。英字の語の間の空白一つも名前の内。 */
+const FOREIGN_CHAR = /[\p{Script=Katakana}\p{Script=Latin}\p{N}ー・&＆'’.\- ]/u;
+/** 形の語のすぐ前の字。カタカナ・長音の印・英字のときだけ、形の語と読む（会社、本社、神社の 社 は読まない）。 */
+const FOREIGN_END = /(?:[\p{Script=Katakana}ー\p{Script=Latin}]|\p{Script=Latin}\.)$/u;
+/** 名前の頭に立たない字（空白、記号、数字だけの頭はそのまま残す）。 */
+const FOREIGN_LEAD = /^[\s・&＆'’.-]+/u;
+/** カタカナの語に一字の記号を付けた仮の名前（ベンダーA、メーカーB）。名前ではないので、A と B を一字違いと見ない。 */
+const PLACEHOLDER = /[\p{Script=Katakana}ー]\s?[\p{Lu}\p{N}]$/u;
+
+/** text の終わりに続く、カタカナか英字の名前の字の始まり。 */
+const foreignRunStart = (text: string): number => {
+  let start = text.length;
+  while (start > 0 && FOREIGN_CHAR.test(text.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** カタカナか英字の名前のすぐ後ろの形の語（サウスベイ・インポート社、Marlow Bay社）。形の語で始まる漢字の語（社員、社長）は外す。 */
+const foreignMentionAt = (source: string, form: CompanyForm, at: number, words: readonly string[]): CompanyMention | undefined => {
+  const before = source.slice(0, at);
+  if (!FOREIGN_END.test(before) || words.some((word) => source.startsWith(word, at))) return undefined;
+  const run = before.slice(foreignRunStart(before));
+  const start = at - run.length + (FOREIGN_LEAD.exec(run)?.[0].length ?? 0);
+  const base = { start, end: at };
+  if (!isNameBase(source, base, () => false) || PLACEHOLDER.test(source.slice(start, at))) return undefined;
+  return { ...mentionOf(source, base, { start: at, end: at + form.pattern.length }, form.group), foreign: true };
+};
+
+const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper, stops: KanaStops): Span | undefined =>
+  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at, stops);
 
 /** 形の語の一つの現れから、会社の名前の現れ。名前が前にあればそれを、無ければ後ろを取る。 */
-const mentionAt = (source: string, form: CompanyForm, at: number, isProper: IsProper): CompanyMention | undefined => {
+const mentionAt = (source: string, form: CompanyForm, at: number, isProper: IsProper, stops: KanaStops): CompanyMention | undefined => {
+  if (form.foreign !== undefined) return foreignMentionAt(source, form, at, form.foreign.words);
   const formSpan = { start: at, end: at + form.pattern.length };
   const latin = LATIN.test(form.pattern);
   if (latin && CONTINUED.test(source.slice(formSpan.end))) return undefined;
-  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper);
+  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper, stops);
   if (before !== undefined && isNameBase(source, before, isProper)) return mentionOf(source, before, formSpan, form.group);
-  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end);
+  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end, stops);
   return after !== undefined && isNameBase(source, after, isProper) ? mentionOf(source, after, formSpan, form.group) : undefined;
 };
 
 /** 文書の中の会社の名前の現れ。長い形の語（Co., Ltd）を先に取り、その中の短い語（Ltd）は数えない。 */
-export const companyMentionsIn = (source: string, forms: readonly CompanyForm[], isProper: IsProper): CompanyMention[] => {
+export const companyMentionsIn = (source: string, forms: readonly CompanyForm[], isProper: IsProper, stops: KanaStops): CompanyMention[] => {
   const taken: Span[] = [];
   return forms
     .toSorted((left, right) => right.pattern.length - left.pattern.length)
@@ -118,7 +209,7 @@ export const companyMentionsIn = (source: string, forms: readonly CompanyForm[],
         const end = at + form.pattern.length;
         if (!standsAsWord(source, form.pattern, at) || taken.some((span) => span.start < end && at < span.end)) return [];
         taken.push({ start: at, end });
-        const mention = mentionAt(source, form, at, isProper);
+        const mention = mentionAt(source, form, at, isProper, stops);
         return mention === undefined ? [] : [mention];
       }),
     )
@@ -130,23 +221,30 @@ const MIN_SLIP_LENGTH = 7;
 const spliced = (chars: readonly string[], at: number, count: number): string => chars.toSpliced(at, count).join("");
 const firstDifference = (left: readonly string[], right: readonly string[]): number => left.findIndex((char, index) => char !== right[index]);
 
+/** 一字違いの、違う字（changed）と、それが立つ名前の字（chars）の何字目か（at）。 */
+type Change = { readonly changed: readonly string[]; readonly chars: readonly string[]; readonly at: number };
+
 /** 一字の抜けなら、その字。 */
-const droppedChars = (longer: readonly string[], shorter: readonly string[]): string[] | undefined => {
+const droppedChars = (longer: readonly string[], shorter: readonly string[]): Change | undefined => {
   if (longer.length !== shorter.length + 1) return undefined;
   const at = firstDifference(longer, shorter);
-  return spliced(longer, at, 1) === shorter.join("") ? [longer[at] ?? ""] : undefined;
+  return spliced(longer, at, 1) === shorter.join("") ? { changed: [longer[at] ?? ""], chars: longer, at } : undefined;
 };
 
 /** 一字の置き換えか、隣どうしの入れ替えなら、その字。 */
-const replacedChars = (left: readonly string[], right: readonly string[]): string[] | undefined => {
+const replacedChars = (left: readonly string[], right: readonly string[]): Change | undefined => {
   const at = firstDifference(left, right);
-  const changed = [left[at] ?? "", right[at] ?? ""];
+  const change = { changed: [left[at] ?? "", right[at] ?? ""], chars: left, at };
   if (left.length !== right.length || at < 0) return undefined;
-  if (spliced(left, at, 1) === spliced(right, at, 1)) return changed;
+  if (spliced(left, at, 1) === spliced(right, at, 1)) return change;
   const swapped = left[at] === right[at + 1] && left[at + 1] === right[at] && spliced(left, at, 2) === spliced(right, at, 2);
-  return swapped ? changed : undefined;
+  return swapped ? change : undefined;
 };
 
+/** 名前の部分の一字違い（置き換え・抜け・隣どうしの入れ替え）。 */
+const changeBetween = (leftChars: readonly string[], rightChars: readonly string[]): Change | undefined =>
+  replacedChars(leftChars, rightChars) ?? droppedChars(leftChars, rightChars) ?? droppedChars(rightChars, leftChars);
+
 /**
  * 名前の部分が一字違いか（置き換え・抜け・隣どうしの入れ替え）。違う字が漢字なら見ない。漢字の一字違い（日本電気 と 日本電機）
  * は別の会社のことがある。短い名前（Alpha と Alpho）も別の会社のことが多い。
@@ -154,13 +252,40 @@ const replacedChars = (left: readonly string[], right: readonly string[]): strin
 const isSlip = (left: string, right: string): boolean => {
   const [leftChars, rightChars] = [[...left], [...right]];
   if (Math.min(leftChars.length, rightChars.length) < MIN_SLIP_LENGTH) return false;
-  const changed = replacedChars(leftChars, rightChars) ?? droppedChars(leftChars, rightChars) ?? droppedChars(rightChars, leftChars);
-  return changed !== undefined && changed.every((char) => NOT_HAN_LETTER.test(char));
+  const change = changeBetween(leftChars, rightChars);
+  return change !== undefined && change.changed.every((char) => NOT_HAN_LETTER.test(char));
+};
+
+const HAN = /\p{Script=Han}/u;
+const KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}ー]$/u;
+/** 漢字を含む短い名前で、一字違いを見るかなの語の字数。三字のかなの語（サンワ と サンヨ）は別の会社のことがある。 */
+const MIN_KANA_WORD_LENGTH = 4;
+
+/** at の字を含む、かなの続きの字数。 */
+const kanaRunLength = (chars: readonly string[], at: number): number => {
+  const isKanaAt = (index: number): boolean => KANA.test(chars[index] ?? "");
+  if (!isKanaAt(at)) return 0;
+  const start = chars.findLastIndex((_char, index) => index < at && !isKanaAt(index)) + 1;
+  const end = chars.findIndex((_char, index) => index > at && !isKanaAt(index));
+  return (end < 0 ? chars.length : end) - start;
 };
 
-/** 名前の部分が同じ二つ。同じ形の短い書き方と長い書き方（株式会社 と (株)、Inc と Incorporated）は書き分けと見ない。 */
+/**
+ * 漢字を含む名前の、四字以上のかなの語の中の、かな一字違い（コモレビ電機 と コモレピ電機）。漢字の部分が同じなので、七字に
+ * 満たない名前でも見る。漢字の一字違い（日本電気 と 日本電機）は見ない。
+ */
+export const isKanaWordSlip = (left: string, right: string): boolean => {
+  if (!HAN.test(left) || !HAN.test(right)) return false;
+  const change = changeBetween([...left], [...right]);
+  return change !== undefined && change.changed.every((char) => KANA.test(char)) && kanaRunLength(change.chars, change.at) >= MIN_KANA_WORD_LENGTH;
+};
+
+/**
+ * 名前の部分が同じ二つ。同じ形の短い書き方と長い書き方（株式会社 と (株)、Inc と Incorporated）は書き分けと見ない。社で呼ぶ書き方
+ * （アップル社 と アップル株式会社）は正式の名前を略した呼び方なので、ほかの形の語と比べない。
+ */
 const sameNameRelation = (left: CompanyMention, right: CompanyMention): CompanyRelation | undefined => {
-  if (left.form !== right.form) return "form";
+  if (left.form !== right.form) return left.foreign === true || right.foreign === true ? undefined : "form";
   if (left.position !== right.position) return "position";
   return nameKey(left.surface) === nameKey(right.surface) ? "spelling" : undefined;
 };
@@ -191,12 +316,20 @@ const talliesOf = (mentions: readonly CompanyMention[]): Tally[] => {
 /** 多いほうが先。同数なら先に書いたほう。 */
 const byUsage = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
 
+/** 短い名前のかなの一字違いは、別の会社のこともあるので、相手が二度以上、こちらが一度だけのときに限る。 */
+const relationBetween = (tally: Tally, other: Tally): CompanyRelation | undefined => {
+  const relation = companyRelation(tally.first, other.first);
+  if (relation !== undefined || tally.count !== 1 || other.count < 2) return relation;
+  const [left, right] = [tally.first, other.first];
+  return left.form === right.form && left.position === right.position && isKanaWordSlip(nameKey(left.base), nameKey(right.base)) ? "near" : undefined;
+};
+
 /** 同じ会社の、少ないほうの書き方。同じ会社と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
 export const companyVariants = (mentions: readonly CompanyMention[]): CompanyVariant[] => {
   const tallies = talliesOf(mentions);
   return tallies.flatMap((tally) => {
-    const [usual] = tallies.filter((other) => other === tally || companyRelation(tally.first, other.first) !== undefined).toSorted(byUsage);
-    const kind = usual === undefined || usual === tally ? undefined : companyRelation(tally.first, usual.first);
+    const [usual] = tallies.filter((other) => other === tally || relationBetween(tally, other) !== undefined).toSorted(byUsage);
+    const kind = usual === undefined || usual === tally ? undefined : relationBetween(tally, usual);
     return usual === undefined || kind === undefined ? [] : [{ mention: tally.first, usual: usual.first.surface, kind }];
   });
 };

package/src/contacts/addresses.ts

@@ -0,0 +1,179 @@
+// Postal addresses written two ways in one document: the same street with its block numbers swapped or one of them changed
+// (丸の内二丁目4番1号 and 丸の内二丁目1番4号, 2-4-1 and 2-1-4 Marunouchi), or the same street and numbers under two postcodes.
+// Only an address with a label shortly before it on its line is read (住所, 本店所在地, Address, head office); the labels come
+// from the language's address-label lexicon, grouped by whose address they name, so a head office and a branch are never
+// compared. Pure.
+import type { LexiconEntry } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { writingVariants, type Variant, type Writing } from "./variants.ts";
+
+/** An address as written: the street it is on and the area written with it (東京都千代田区, Chiyoda-ku), its block numbers, its postcode when the line has one, and its label's group. */
+export type AddressWriting = Writing & {
+  readonly street: string;
+  readonly area: string;
+  readonly numbers: readonly number[];
+  readonly postcode: string | undefined;
+  readonly label: string;
+};
+
+/** A group that names no one office (住所, Address) and so may be compared with any. */
+const ANY_OFFICE = "address";
+const KANA_HAN = String.raw`\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}ー々ヶ`;
+const BLOCK_JOIN = String.raw`\s?(?:丁目|番地|番|号|の|[-‐−－])\s?`;
+/** A Japanese street (its town, ward, city) and its block numbers: 東京都千代田区丸の内二丁目4番1号, 梅田1-2-3. */
+const JA_ADDRESS = new RegExp(String.raw`([${KANA_HAN}]{2,40}?)([0-9０-９]{1,4}(?:${BLOCK_JOIN}[0-9０-９]{1,4}){1,3})(?:\s?(?:号|番地|番))?`, "gu");
+/** Block numbers, the capitalised street after them and the area after a comma: 2-4-1 Marunouchi, Chiyoda-ku; 120 Main Street, Springfield. */
+const EN_BLOCK = String.raw`(?<![\w.\-/])(\d{1,5}(?:-\d{1,5}){0,3})`;
+const EN_STREET = String.raw`([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})`;
+const EN_AREA = String.raw`(?:,\s?([A-Z][A-Za-z]*(?:-[a-z]+)?))?`;
+const EN_ADDRESS = new RegExp(String.raw`${EN_BLOCK}\s+${EN_STREET}${EN_AREA}`, "gu");
+/** 都道府県, 市, 区 and 郡: what comes after the last of them in a Japanese street is the town the numbers count in. */
+const DIVISIONS = [..."都道府県市区郡"];
+const CHOME = "丁目";
+const KANJI_NUMERALS = "一二三四五六七八九十";
+const KANJI_DIGITS = "一二三四五六七八九";
+const JP_POSTCODE = /(?<![\d\-‐−－])〒?\s?(\d{3})[-‐−－](\d{4})(?![\d\-‐−－])/u;
+const US_ZIP = /\b[A-Z]{2}\s(\d{5})(?:-\d{4})?\b/u;
+const JP_POSTCODE_ONLY = /^\d{3}-\d{4}$/u;
+const YEAR = /^(?:19|20)\d{2}$/u;
+const FULL_WIDTH_DIGIT = /[０-９]/gu;
+const NUMBER = /\d+/gu;
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+/** How far before an address its label may end: 「本店所在地（」, "head office at ". */
+const MAX_LABEL_GAP = 20;
+const MIN_STREET_LENGTH = 2;
+
+/** 一 to 九十九 as a number; the 丁目 of a Japanese street. */
+const kanjiNumber = (kanji: string): number => {
+  const digit = (char: string): number => KANJI_DIGITS.indexOf(char) + 1;
+  if (!kanji.includes("十")) return digit(kanji);
+  const [tens = "", ones = ""] = kanji.split("十");
+  return (tens === "" ? 1 : digit(tens)) * 10 + (ones === "" ? 0 : digit(ones));
+};
+
+const halfWidth = (text: string): string => text.replaceAll(FULL_WIDTH_DIGIT, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0));
+const numbersOf = (text: string): number[] => [...halfWidth(text).matchAll(NUMBER)].map((match) => Number(match[0]));
+
+/** The 二丁目 a street ends with, or "" when it ends with none. */
+const chomeOf = (street: string): string => {
+  if (!street.endsWith(CHOME)) return "";
+  const numeral = Array.from(street.slice(0, -CHOME.length))
+    .toReversed()
+    .findIndex((char) => !KANJI_NUMERALS.includes(char));
+  const length = numeral === -1 ? street.length - CHOME.length : numeral;
+  return length === 0 ? "" : street.slice(street.length - CHOME.length - length);
+};
+
+/** The town of a Japanese street as written (丸の内二丁目), its name without the 丁目 and the 丁目 as a number; undefined when the street names no ward, city or prefecture. */
+const jaStreet = (run: string): { area: string; written: string; town: string; chome: number[] } | undefined => {
+  const lastDivision = Math.max(...DIVISIONS.map((division) => run.lastIndexOf(division)));
+  if (lastDivision < 0) return undefined;
+  const written = run.slice(lastDivision + 1);
+  const chome = chomeOf(written);
+  const town = written.slice(0, written.length - chome.length);
+  const numbered = chome === "" ? [] : [kanjiNumber(chome.slice(0, -CHOME.length))];
+  return town.length < MIN_STREET_LENGTH ? undefined : { area: run.slice(0, lastDivision + 1), written, town, chome: numbered };
+};
+
+type Place = { readonly offset: number; readonly written: string; readonly street: string; readonly area: string; readonly numbers: number[] };
+
+const jaPlaces = (text: string): Place[] =>
+  [...text.matchAll(JA_ADDRESS)].flatMap((match) => {
+    const run = match[1] ?? "";
+    const street = jaStreet(run);
+    if (street === undefined) return [];
+    const townStart = run.length - street.written.length;
+    return [
+      {
+        offset: match.index + townStart,
+        written: match[0].slice(townStart),
+        street: street.town,
+        area: street.area,
+        numbers: [...street.chome, ...numbersOf(match[2] ?? "")],
+      },
+    ];
+  });
+
+/** A lone number before capitalised words is an address only when a comma goes on to the area (120 Main Street, Springfield), not a count (365 Plan). */
+const isAddressBlock = (block: string, area: string): boolean => block.includes("-") || area !== "";
+
+const enPlaces = (text: string): Place[] =>
+  [...text.matchAll(EN_ADDRESS)].flatMap((match) => {
+    const [, block = "", street = "", area = ""] = match;
+    if (JP_POSTCODE_ONLY.test(block) || YEAR.test(block) || !isAddressBlock(block, area)) return [];
+    return [{ offset: match.index, written: `${block} ${street}`, street: street.toLowerCase(), area: area.toLowerCase(), numbers: numbersOf(block) }];
+  });
+
+/** Where a label last occurs before an address on its line; a Latin label only as a whole word (office, not officer). */
+const lastPlace = (before: string, label: string): number => {
+  const lowered = label.toLowerCase();
+  const places = [...before.matchAll(new RegExp(escapeRegExp(lowered), "gu"))].map((match) => match.index);
+  const whole = LATIN_START.test(label) ? places.filter((at) => !LETTER.test(before[at - 1] ?? "") && !LETTER.test(before[at + lowered.length] ?? "")) : places;
+  return whole.at(-1) ?? -1;
+};
+
+/** The group of the label ending nearest before an address on its line, the longest when two end together (本店所在地 over 所在地). */
+const labelBefore = (before: string, labels: readonly LexiconEntry[]): string | undefined =>
+  labels
+    .map((entry) => {
+      const at = lastPlace(before, entry.pattern);
+      return { group: entry.group ?? ANY_OFFICE, 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]?.group;
+
+const postcodeOf = (line: string): string | undefined => {
+  const japanese = JP_POSTCODE.exec(line);
+  if (japanese !== null) return `${japanese[1] ?? ""}-${japanese[2] ?? ""}`;
+  return US_ZIP.exec(line)?.[1];
+};
+
+/** The labelled addresses of one line; its postcode is given to an address only when the line holds one address. */
+const lineAddresses = (line: string, start: number, labels: readonly LexiconEntry[]): AddressWriting[] => {
+  const places = [...jaPlaces(line), ...enPlaces(line)];
+  const postcode = places.length === 1 ? postcodeOf(line) : undefined;
+  return places.flatMap((place) => {
+    const label = labelBefore(line.slice(0, place.offset).toLowerCase(), labels);
+    if (label === undefined) return [];
+    const key = `${place.street}\u0000${place.numbers.join("-")}`;
+    return [{ ...place, offset: start + place.offset, key, postcode, label }];
+  });
+};
+
+/** The postal addresses of a text that have a label shortly before them on their line. */
+export const labelledAddresses = (text: string, labels: readonly LexiconEntry[]): AddressWriting[] => {
+  const lines = text.split("\n");
+  const starts = lines.reduce<number[]>((acc, line, index) => [...acc, index === 0 ? 0 : (acc[index - 1] ?? 0) + (lines[index - 1] ?? "").length + 1], []);
+  return lines.flatMap((line, index) => lineAddresses(line, starts[index] ?? 0, labels));
+};
+
+/** Two lists of block numbers that are one address mistyped: the same numbers in another order, or one of them changed. */
+export const isBlockSlip = (a: readonly number[], b: readonly number[]): boolean => {
+  if (a.length !== b.length || a.join("-") === b.join("-")) return false;
+  const sorted = (numbers: readonly number[]): string => numbers.toSorted((x, y) => x - y).join("-");
+  const differing = a.filter((number, index) => number !== b[index]).length;
+  return sorted(a) === sorted(b) || differing === 1;
+};
+
+/** Whether two writings are on one street: the same town or street name, in the same area where both write one (千代田区 within 東京都千代田区). */
+const sameStreet = (a: AddressWriting, b: AddressWriting): boolean => a.street === b.street && (a.area.endsWith(b.area) || b.area.endsWith(a.area));
+
+const sameOffice = (a: AddressWriting, b: AddressWriting): boolean => a.label === b.label || a.label === ANY_OFFICE || b.label === ANY_OFFICE;
+
+export type AddressVariant = { readonly variant: "address" | "postcode"; readonly found: Variant<AddressWriting> };
+
+/** Every writing of an address that is another of the same street with its numbers mistyped, or under another postcode. */
+export const addressVariants = (text: string, labels: readonly LexiconEntry[]): AddressVariant[] => {
+  const addresses = labelledAddresses(text, labels);
+  const numbered = writingVariants(addresses, (a, b) => sameStreet(a, b) && sameOffice(a, b) && isBlockSlip(a.numbers, b.numbers));
+  const withPostcode = addresses.flatMap((address) => (address.postcode === undefined ? [] : [{ ...address, key: `${address.key}\u0000${address.postcode}` }]));
+  const postcoded = writingVariants(
+    withPostcode,
+    (a, b) => sameStreet(a, b) && a.numbers.join("-") === b.numbers.join("-") && a.postcode !== b.postcode && sameOffice(a, b),
+  );
+  const tagged =
+    (variant: AddressVariant["variant"]) =>
+    (found: Variant<AddressWriting>): AddressVariant => ({ variant, found });
+  return [...numbered.map(tagged("address")), ...postcoded.map(tagged("postcode"))];
+};

package/src/contacts/emails.ts

@@ -0,0 +1,63 @@
+// Email addresses written two ways in one document (support@hibari-lab.example and suport@hibari-lab.example). Two addresses
+// are one contact misspelt only when everything but one word of them is the same, so sales@ and support@ of one domain, or
+// one mailbox at two domains that differ by more than a slip, stay apart. Pure.
+import { writingVariants, type Variant, type Writing } from "./variants.ts";
+
+export type EmailWriting = Writing;
+
+const EMAIL = /(?<![\w.%+-])[a-z0-9][a-z0-9._%+-]*@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+/giu;
+const SEPARATOR = /[.@\-_+%]/u;
+const SEPARATORS = /[.\-_]/gu;
+const DIGIT = /\d/u;
+/** A word shorter than this is a whole name (hr, pr, jp, sale, info), not one to be misspelt. */
+const MIN_WORD_LENGTH = 5;
+/** Longer than this, a word is an id rather than a name, and is not compared. */
+const MAX_WORD_LENGTH = 64;
+/** From this length a word may differ by two edits and still be a slip; a shorter one by one. */
+const TWO_EDIT_LENGTH = 6;
+
+/** The email addresses of a text, lower-cased into their key. */
+export const emailWritings = (text: string): EmailWriting[] =>
+  [...text.matchAll(EMAIL)].map((match) => ({ offset: match.index, written: match[0], key: match[0].toLowerCase() }));
+
+/** Edits (insert, delete, replace, swap of neighbours) between two short strings: the optimal string alignment distance. */
+export const editDistance = (a: string, b: string): number => {
+  const rows = [...a].reduce<number[][]>(
+    (done, charA, i) => {
+      const previous = done[i] ?? [];
+      const row = [...b].reduce<number[]>(
+        (cells, charB, j) => {
+          const cost = charA === charB ? 0 : 1;
+          const swapped = i > 0 && j > 0 && charA === b[j - 1] && a[i - 1] === charB ? (done[i - 1]?.[j - 1] ?? Infinity) + 1 : Infinity;
+          return [...cells, Math.min((previous[j + 1] ?? Infinity) + 1, (cells[j] ?? Infinity) + 1, (previous[j] ?? Infinity) + cost, swapped)];
+        },
+        [i + 1],
+      );
+      return [...done, row];
+    },
+    [[...Array(b.length + 1).keys()]],
+  );
+  return rows.at(-1)?.at(-1) ?? 0;
+};
+
+const separatorsOf = (address: string): string => [...address].filter((char) => SEPARATOR.test(char)).join("");
+
+/** One word of the two differs, by a slip: both long enough, no digits (support1@ and support2@ are two mailboxes). */
+const oneWordSlip = (a: string, b: string): boolean => {
+  if (separatorsOf(a) !== separatorsOf(b)) return false;
+  const wordsA = a.split(SEPARATOR);
+  const wordsB = b.split(SEPARATOR);
+  const differing = wordsA.flatMap((word, index): [string, string][] => (word === wordsB[index] ? [] : [[word, wordsB[index] ?? ""]]));
+  const [pair] = differing;
+  if (differing.length !== 1 || pair === undefined) return false;
+  const [wordA, wordB] = pair;
+  const shorter = Math.min(wordA.length, wordB.length);
+  if (shorter < MIN_WORD_LENGTH || Math.max(wordA.length, wordB.length) > MAX_WORD_LENGTH || DIGIT.test(wordA) || DIGIT.test(wordB)) return false;
+  return editDistance(wordA, wordB) <= (shorter >= TWO_EDIT_LENGTH ? 2 : 1);
+};
+
+/** Whether two addresses are one written two ways: a dot or hyphen dropped or added, or one word misspelt. */
+export const isEmailSlip = (a: string, b: string): boolean => a !== b && (a.replaceAll(SEPARATORS, "") === b.replaceAll(SEPARATORS, "") || oneWordSlip(a, b));
+
+/** Every writing of an address that is another address of the document written with a slip, with that other address. */
+export const emailVariants = (text: string): Variant<EmailWriting>[] => writingVariants(emailWritings(text), (a, b) => isEmailSlip(a.key, b.key));