chaffjs 0.28.0 → 0.30.0

package/src/nado-closed-list.ts

@@ -0,0 +1,106 @@
+// A list left open (等, など, etc.) that a limit closes in the same breath (自転車等に限ります, only A, B, etc.). Pure: reads one
+// sentence's text and tokens; the open words, the limits and the phrases that look like a limit without being one come
+// from the language's nado-closed-list lexicon.
+import type { LexiconEntry, Token } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+export type ClosedListWords = {
+  readonly open: readonly string[];
+  /** A limit right after the open word (等に限り, etc. only). */
+  readonly limitsAfter: readonly string[];
+  /** A limit before the list it governs (only A, B, etc.). */
+  readonly limitsBefore: readonly string[];
+  /** A phrase holding a limit's letters that closes nothing (に限らず, not only). */
+  readonly notLimits: readonly string[];
+};
+
+/** An open word on a closed list: where it is in the sentence, the word and the limit. */
+export type OpenOnClosed = { readonly offset: number; readonly open: string; readonly limit: string };
+
+const patternsOf = (entries: readonly LexiconEntry[], group: string, position?: "before" | "after"): string[] =>
+  entries.filter((entry) => entry.group === group && (position === undefined || entry.position === position)).map((entry) => entry.pattern);
+
+export const closedListWordsOf = (entries: readonly LexiconEntry[]): ClosedListWords => ({
+  open: patternsOf(entries, "open"),
+  limitsAfter: patternsOf(entries, "limit", "after"),
+  limitsBefore: patternsOf(entries, "limit", "before"),
+  notLimits: patternsOf(entries, "not-limit"),
+});
+
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+/** What may stand between an open word and a limit right after it: spaces, a comma, a closing bracket. */
+const BETWEEN_OPEN_AND_LIMIT = /^[\s,、)）」』]*/u;
+/** A word that is a counter or a class (1等, 2等), not an open word, by the tagger's features. */
+const CLASS_NOUN = "Class";
+/** What makes the words between a limit and an open word a clause of their own, not the list it governs. */
+const CLAUSE_POS: ReadonlySet<string> = new Set(["AUX", "VERB"]);
+/** A verb form that modifies a noun inside a list (a driving licence, used cars). */
+const NOUN_MODIFYING_FORMS: ReadonlySet<string> = new Set(["Ger", "Part"]);
+const LIST_SEPARATOR = /[,、]/u;
+
+/** Where a word occurs in a text; a Latin word only as whole words, any case. */
+const placesOf = (text: string, word: string): number[] => {
+  const latin = LATIN_START.test(word);
+  const matches = [...text.matchAll(new RegExp(escapeRegExp(word), latin ? "giu" : "gu"))].map((match) => match.index);
+  if (!latin) return matches;
+  return matches.filter((at) => !LETTER.test(text[at - 1] ?? "") && !LETTER.test(text[at + word.length] ?? ""));
+};
+
+const startsWithWord = (text: string, word: string): boolean => placesOf(text.slice(0, word.length + 1), word).includes(0);
+
+/**
+ * The open word stands as a word of its own: a token starts there, is no longer than the word (等しい, 同等 are other
+ * words), and is not a counter (1等). Token spans are the sentence's own offsets. Without tokens only a Latin word is read.
+ */
+const standsAsOpenWord = (tokens: readonly Token[], at: number, open: string): boolean => {
+  if (tokens.length === 0) return LATIN_START.test(open);
+  const token = tokens.find((candidate) => candidate.span.start === at);
+  return token !== undefined && open.toLowerCase().startsWith(token.surface.toLowerCase()) && token.features?.NounType !== CLASS_NOUN;
+};
+
+const limitRightAfter = (rest: string, words: ClosedListWords): string | undefined => {
+  const after = rest.slice(BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0].length ?? 0);
+  if (words.notLimits.some((phrase) => startsWithWord(after, phrase))) return undefined;
+  return longestFirst(words.limitsAfter).find((limit) => startsWithWord(after, limit));
+};
+
+const longestFirst = (words: readonly string[]): string[] => [...words].sort((a, b) => b.length - a.length);
+
+const insideNotLimit = (text: string, at: number, notLimits: readonly string[]): boolean =>
+  notLimits.some((phrase) => placesOf(text, phrase).some((start) => start <= at && at < start + phrase.length));
+
+const OPEN_BRACKETS = /[(（]/gu;
+const CLOSE_BRACKETS = /[)）]/gu;
+
+/** A bracket opened and not closed between the limit and the list: the list explains a word the limit governs. */
+const opensBracket = (between: string): boolean => (between.match(OPEN_BRACKETS)?.length ?? 0) > (between.match(CLOSE_BRACKETS)?.length ?? 0);
+
+/** The words between a limit and the open word are a list it governs: separated by commas, with no clause of their own. */
+const governsList = (text: string, tokens: readonly Token[], from: number, to: number): boolean =>
+  LIST_SEPARATOR.test(text.slice(from, to)) &&
+  !opensBracket(text.slice(from, to)) &&
+  !tokens.some(
+    (token) => token.span.start >= from && token.span.end <= to && CLAUSE_POS.has(token.pos) && !NOUN_MODIFYING_FORMS.has(token.features?.VerbForm ?? ""),
+  );
+
+const limitBefore = (text: string, tokens: readonly Token[], at: number, words: ClosedListWords): string | undefined => {
+  const limits = words.limitsBefore.flatMap((limit) =>
+    placesOf(text.slice(0, at), limit).map((start) => ({ limit, start, end: start + limit.length, negated: insideNotLimit(text, start, words.notLimits) })),
+  );
+  const nearest = limits.toSorted((a, b) => b.start - a.start)[0];
+  if (nearest === undefined || nearest.negated) return undefined;
+  return governsList(text, tokens, nearest.end, at) ? nearest.limit : undefined;
+};
+
+/** The open words of one sentence that a limit closes, by their offset in the sentence. */
+export const openWordsOnClosedLists = (text: string, tokens: readonly Token[], words: ClosedListWords): OpenOnClosed[] =>
+  words.open
+    .flatMap((open) => placesOf(text, open).map((at) => ({ open, at })))
+    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open))
+    .flatMap(({ open, at }) => {
+      const limit = limitRightAfter(text.slice(at + open.length), words) ?? limitBefore(text, tokens, at, words);
+      return limit === undefined ? [] : [{ offset: at, open, limit }];
+    })
+    .sort((a, b) => a.offset - b.offset || b.open.length - a.open.length)
+    .filter((hit, index, hits) => hits[index - 1]?.offset !== hit.offset);

package/src/name-cue.ts

@@ -0,0 +1,35 @@
+// 敬称も、解析器の人名の印も無い名前（担当の斎藤です、斉藤までご連絡ください）を、前後の語から人の名前と読む。
+
+/** 人を指す前置き（担当の、私、）、敬称（様、さん）、名前のすぐ後ろに来る語（です、まで）。語彙表から。 */
+export type NameCues = { readonly leads: readonly string[]; readonly suffixes: readonly string[]; readonly particles: readonly string[] };
+
+/**
+ * person: 人の名前と言える（前に「担当の」、後ろに敬称）。slot: 名前の来る場所（後ろに「です」「まで」）。bare: どちらでもない。
+ * 名前の形でないもの（字数が違う、漢字以外を含む、長い漢字の連なりの一部）は undefined。
+ */
+export type NameCue = "person" | "slot" | "bare";
+
+const MIN_NAME = 2;
+const MAX_NAME = 4;
+/** 前後の一字を読むのに要る長さ（UTF-16 の単位）。𠮷 は二つ。 */
+const SURROGATE_PAIR = 2;
+const HAN = /^\p{Script=Han}$/u;
+
+const isHan = (letter: string | undefined): boolean => letter !== undefined && HAN.test(letter);
+
+/**
+ * offset から書いた surface を、前後の語で読む。名前は 2〜4 字の漢字で、前後に漢字が続かない（鹿嶋市、株式会社髙橋は地名や会社の名前の
+ * 一部）。敬称だけは漢字（様、氏）でも名前のすぐ後ろに続いてよい。
+ */
+export const nameCueAt = (text: string, offset: number, surface: string, cues: NameCues): NameCue | undefined => {
+  const letters = [...surface];
+  if (letters.length < MIN_NAME || letters.length > MAX_NAME || !letters.every((letter) => isHan(letter))) return undefined;
+  const context = Math.max(SURROGATE_PAIR, ...[...cues.leads, ...cues.suffixes, ...cues.particles].map((word) => word.length));
+  const before = text.slice(Math.max(0, offset - context), offset);
+  const after = text.slice(offset + surface.length, offset + surface.length + context);
+  if (isHan([...before].at(-1))) return undefined;
+  if (cues.suffixes.some((suffix) => after.startsWith(suffix))) return "person";
+  if (isHan([...after][0])) return undefined;
+  if (cues.leads.some((lead) => before.endsWith(lead))) return "person";
+  return cues.particles.some((particle) => after.startsWith(particle)) ? "slot" : "bare";
+};

package/src/name-variants.ts

@@ -1,5 +1,7 @@
 import type { Token } from "./plugin.ts";
 import { escapeRegExp } from "./orthography.ts";
+import { nameCueAt, type NameCue, type NameCues } from "./name-cue.ts";
+import { isNearSurname } from "./surname-near.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
@@ -7,7 +9,7 @@ import { escapeRegExp } from "./orthography.ts";
 
 /**
  * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
- * 人名と読むか、敬称が付く）。
+ * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。
  */
 export type NameMention = {
   readonly surface: string;
@@ -15,9 +17,14 @@ export type NameMention = {
   readonly reading: string | undefined;
   readonly words: readonly string[];
   readonly person?: boolean;
+  readonly cue?: NameCue;
 };
 
-export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" | "character" };
+export type NameVariant = {
+  readonly mention: NameMention;
+  readonly usual: string;
+  readonly kind: "spelling" | "reading" | "near" | "surname" | "character";
+};
 
 /** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
 export type VariantChars = ReadonlyMap<string, string>;
@@ -97,6 +104,61 @@ export const mentionsIn = (tokens: readonly Token[], source: string, personSuffi
     return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface), person }];
   });
 
+/** 隣の語を探す範囲（UTF-16 の単位）。 */
+const NEIGHBOUR_LOOKBACK = 40;
+/** 隣の語の外側の記号（(Rachel、Floyd.）。名前の側の記号（Rachel, Whitford の ,）は語を切るので残す。 */
+const MARK = /\p{P}/u;
+const withoutLeadingMarks = (word: string): string => {
+  const chars = [...word];
+  const start = chars.findIndex((char) => !MARK.test(char));
+  return start < 0 ? "" : chars.slice(start).join("");
+};
+const withoutTrailingMarks = (word: string): string => {
+  const chars = [...word];
+  return chars.slice(0, chars.findLastIndex((char) => !MARK.test(char)) + 1).join("");
+};
+
+const wordBeforeAt = (source: string, offset: number): string | undefined => {
+  if (source.charAt(offset - 1) !== " ") return undefined;
+  const from = Math.max(0, offset - 1 - NEIGHBOUR_LOOKBACK);
+  const parts = source.slice(from, offset - 1).split(/\s/u);
+  const word = withoutLeadingMarks(parts.at(-1) ?? "");
+  return word === "" || (from > 0 && parts.length === 1) ? undefined : word;
+};
+
+const wordAfterAt = (source: string, end: number): string | undefined => {
+  if (source.charAt(end) !== " ") return undefined;
+  const word = withoutTrailingMarks(source.slice(end + 1, end + 1 + NEIGHBOUR_LOOKBACK).split(/\s/u)[0] ?? "");
+  return word === "" ? undefined : word;
+};
+
+/**
+ * 解析器が名前の一語を名前と読まなかった所（to Rachel Whitford の Rachel を動詞と読む）。空白一つで隣の語と合わせた形を、ほかの所で
+ * 名前と読めていれば、その形の現れと見る。隣の語がほかの名前の現れに入るなら合わせない。
+ */
+export const withKnownNeighbours = (mentions: readonly NameMention[], source: string): NameMention[] => {
+  const known = new Set(mentions.filter((mention) => mention.words.length >= 2).map((mention) => mention.surface));
+  const taken = (start: number, end: number): boolean => mentions.some((mention) => mention.offset < end && start < mention.offset + mention.surface.length);
+  return mentions.map((mention) => {
+    const end = mention.offset + mention.surface.length;
+    const before = wordBeforeAt(source, mention.offset);
+    const after = wordAfterAt(source, end);
+    if (before !== undefined && known.has(`${before} ${mention.surface}`) && !taken(mention.offset - 1 - before.length, mention.offset - 1)) {
+      return {
+        ...mention,
+        surface: `${before} ${mention.surface}`,
+        offset: mention.offset - 1 - before.length,
+        reading: undefined,
+        words: [before, ...mention.words],
+      };
+    }
+    if (after !== undefined && known.has(`${mention.surface} ${after}`) && !taken(end + 1, end + 1 + after.length)) {
+      return { ...mention, surface: `${mention.surface} ${after}`, reading: undefined, words: [...mention.words, after] };
+    }
+    return mention;
+  });
+};
+
 /** 敬称の前の名前の字数（髙橋、髙橋太郎）。長い漢字の連なり（株式会社髙橋）は名前だけを切り出せない。 */
 const MAX_SUFFIXED_NAME = 4;
 const MIN_SUFFIXED_NAME = 2;
@@ -126,6 +188,22 @@ export const suffixedNamesIn = (source: string, suffixes: readonly string[], cha
     }),
   );
 
+const HAN_RUN = /\p{Script=Han}+/gu;
+
+/**
+ * 解析器が名前と読めず、敬称も無いが、前後の語で名前と読める、字体の違う字を含む漢字（担当の髙橋です、髙橋まで）。
+ * ほかの名前の現れと重ならないもの。
+ */
+export const cuedNamesIn = (source: string, cues: NameCues, chars: VariantChars, taken: readonly NameMention[]): NameMention[] =>
+  [...source.matchAll(HAN_RUN)].flatMap((match) => {
+    const [run] = match;
+    const cue = nameCueAt(source, match.index, run, cues);
+    if (cue === undefined || cue === "bare" || ![...run].some((letter) => chars.has(letter))) return [];
+    const end = match.index + run.length;
+    if (taken.some((mention) => mention.offset < end && match.index < mention.offset + mention.surface.length)) return [];
+    return [{ surface: run, offset: match.index, reading: undefined, words: [run], cue }];
+  });
+
 /** 比べる形。幅（ＡＷＳ と AWS）、大文字小文字、空白と記号は名前を変えない。 */
 export const nameKey = (surface: string): string =>
   surface
@@ -133,19 +211,38 @@ export const nameKey = (surface: string): string =>
     .toLowerCase()
     .replaceAll(/[\s\p{P}\p{S}]/gu, "");
 
-/** person: どれかの現れが人の名前と読める。 */
-type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number; readonly person: boolean };
+/**
+ * 名前の現れから言えること。person: 人の名前と読める。named: 人を指す前置きか敬称が付く。nameLike: 名前の来る場所にある（前置き
+ * か敬称、名前のすぐ後ろに来る語）。解析器の人名の印は地名にも付く（鹿嶋へ）ので、nameLike には数えない。
+ */
+export type NameEvidence = { readonly person: boolean; readonly named: boolean; readonly nameLike: boolean };
+
+type Tally = NameEvidence & { readonly surface: string; readonly first: NameMention; readonly count: number };
 
+const evidenceOf = (mention: NameMention): NameEvidence => ({
+  person: mention.person === true,
+  named: mention.cue === "person",
+  nameLike: mention.cue === "person" || mention.cue === "slot",
+});
+
+/** 書き方ごとの数と、どれかの現れが言えること。 */
 const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
-  const tallies = new Map<string, { surface: string; first: NameMention; count: number; person: boolean }>();
+  const tallies = new Map<string, Tally>();
   mentions.forEach((mention) => {
     const tally = tallies.get(mention.surface);
-    const person = mention.person === true;
-    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1, person });
-    else {
-      tally.count += 1;
-      tally.person ||= person;
-    }
+    const evidence = evidenceOf(mention);
+    tallies.set(
+      mention.surface,
+      tally === undefined
+        ? { surface: mention.surface, first: mention, count: 1, ...evidence }
+        : {
+            ...tally,
+            count: tally.count + 1,
+            person: tally.person || evidence.person,
+            named: tally.named || evidence.named,
+            nameLike: tally.nameLike || evidence.nameLike,
+          },
+    );
   });
   return [...tallies.values()];
 };
@@ -246,17 +343,40 @@ const isSlipOf = (tally: Tally, other: Tally): boolean => {
 
 const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
 
+/**
+ * 名が同じで姓だけが二字ほど違う人の名前（Rachel Whitford と Rachel Whitfield）。一字違い（near）より遠いので、名と姓の二語以上
+ * で、違うのが最後の語のときに限る。相手が二度以上、こちらが一度だけ。名の違う二人（Sara Whitford と Rachel Whitfield）は比べない。
+ */
+const isSurnameSlipOf = (tally: Tally, other: Tally): boolean => {
+  if (tally.count !== 1 || other.count < 2) return false;
+  const [words, others] = [wordsOf(tally.surface), wordsOf(other.surface)];
+  const last = words.length - 1;
+  const sameBefore = words.slice(0, last).every((word, index) => word === others[index]);
+  return last >= 1 && words.length === others.length && sameBefore && isNearSurname(words[last] ?? "", others[last] ?? "");
+};
+
+const surnameVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "surname", isSurnameSlipOf);
+
 /** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
 const characterKey = (tally: Tally, chars: VariantChars): string => [...tally.surface].map((letter) => chars.get(letter) ?? letter).join("");
 
+/**
+ * 字体の違う字で書き分けた二つを、同じ人の名前と見るか。どちらも人の名前と読めるか、片方に人を指す前置きか敬称が付き
+ * （担当の斎藤です）、もう片方が名前の来る場所にある（斉藤まで）。地名にも同じ組がある（鹿島 と 鹿嶋）ので、名前の来る場所どうし
+ * だけでは見ない。
+ */
+export const isCharacterPair = (left: NameEvidence, right: NameEvidence): boolean =>
+  (left.person && right.person) || (left.named && right.nameLike) || (right.named && left.nameLike);
+
 /** 人の名前を、字体の違う同じ字（斎藤 と 斉藤、渡辺 と 渡邊）で書き分けた所。 */
 const characterVariants = (tallies: readonly Tally[], chars: VariantChars): NameVariant[] =>
   variantsIn(
     groupBy(
-      tallies.filter((tally) => tally.person),
+      tallies.filter((tally) => tally.person || tally.nameLike),
       (tally) => [characterKey(tally, chars)],
     ),
     "character",
+    isCharacterPair,
   );
 
 /** 字数が同じで、一字だけが違う（松本 と 松元）。 */
@@ -298,6 +418,7 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
       oneWordApart,
     ),
     ...nearVariants(tallies),
+    ...surnameVariants(tallies),
     ...characterVariants(tallies, chars),
     ...personReadingVariants(tallies),
   ];

package/src/name-word-order.ts

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

package/src/paragraph-runs.ts

@@ -14,13 +14,23 @@ const isAdjacent = (source: string, before: Paragraph, after: Paragraph): boolea
   return between.trim() === "" && BLANK_LINE.test(between);
 };
 
+/** A sentence's last mark, past closing quotes, brackets and emphasis marks. */
+const SENTENCE_END = /[。．.!?！？]["'”’」』)）\]］}｝】》〕〉〛*_]*$/u;
+
+/**
+ * Whether a paragraph ends as a sentence does. One that does not is a label, a field, a line of a flattened table or a heading
+ * written as plain text (日時：, Authors, 490 Ratings), which sets nothing apart.
+ */
+export const endsAsSentence = (source: string, paragraph: Paragraph): boolean =>
+  SENTENCE_END.test(source.slice(paragraph.span.start, paragraph.span.end).trim());
+
 /**
  * Each run of adjacent one-sentence paragraphs, in document order, as the paragraphs it holds. A paragraph of two sentences or
- * more, or anything between two paragraphs, ends the run.
+ * more, a paragraph that does not end as a sentence, or anything between two paragraphs, ends the run.
  */
 export const oneSentenceRuns = (source: string, paragraphs: readonly Paragraph[]): Paragraph[][] =>
   paragraphs.reduce<Paragraph[][]>((runs, paragraph, at) => {
-    if (paragraph.sentences.length !== 1) return runs;
+    if (paragraph.sentences.length !== 1 || !endsAsSentence(source, paragraph)) return runs;
     const previous = paragraphs[at - 1];
     const current = runs.at(-1);
     const continues = previous !== undefined && current?.at(-1) === previous && isAdjacent(source, previous, paragraph);