chaffjs 0.29.0 → 0.30.0

package/src/detectors/party-order.ts

@@ -0,0 +1,50 @@
+// Party names listed in the reverse of the document's usual order (乙及び甲 where the contract otherwise writes 甲及び乙). The
+// names are the parties the document defines and the language package's standard ones (party-order-label); the words that list
+// them are its party-order-joiner list. A direction (乙から甲へ, 甲が乙に) is no listing and is not read.
+import { definedTerms } from "../structure/definition-use.ts";
+import { partiesOf } from "../structure/party-role.ts";
+import { partyListings, reversedListings, type ListingWords } from "../structure/party-order.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+/** The usual order is the one written at least this many times as often as its reverse: a tie or near-tie is no convention. */
+const MIN_USUAL_RATIO = 2;
+const SERIES_GROUP = "series";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const listingWords = (doc: ProseDocument): ListingWords => {
+  const standard = patternsOf(doc, "party-order-label");
+  const terms = doc.structure === undefined ? [] : definedTerms(doc.structure);
+  const parties = partiesOf(doc.source, terms, {
+    roles: patternsOf(doc, "party-role"),
+    shortNames: patternsOf(doc, "party-short-name"),
+    companyForms: patternsOf(doc, "company-form"),
+  });
+  const joiners = doc.lexicons["party-order-joiner"] ?? [];
+  return {
+    labels: [...new Set([...standard, ...parties.map((party) => party.term)])],
+    bareLabels: standard,
+    joiners: joiners.filter((entry) => entry.group !== SERIES_GROUP).map((entry) => entry.pattern),
+    seriesMarks: joiners.filter((entry) => entry.group === SERIES_GROUP).map((entry) => entry.pattern),
+  };
+};
+
+export const partyOrder: Detector = (doc): Finding[] => {
+  const texts = doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+  const textOf = (listing: { readonly start: number; readonly end: number }): string => doc.source.slice(listing.start, listing.end);
+  return reversedListings(partyListings(texts, listingWords(doc)), MIN_USUAL_RATIO).map((slip) => ({
+    rule: "party-order",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.listing.start),
+    values: {
+      written: textOf(slip.listing),
+      usual: textOf(slip.usual),
+      usualCount: slip.usualCount,
+      reverseCount: slip.reverseCount,
+      offset: slip.listing.start,
+    },
+  }));
+};

package/src/detectors/registry/connection-time-short.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { connectionTimeShort } from "../time-order.ts";
+
+export const detector: Detector = connectionTimeShort;

package/src/detectors/registry/duration-product-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { durationProductMismatch } from "../derived-numbers.ts";
+
+export const detector: Detector = durationProductMismatch;

package/src/detectors/registry/party-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { partyOrder } from "../party-order.ts";
+
+export const detector: Detector = partyOrder;

package/src/detectors/registry/requirement-lists.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { requirementLists } from "../requirement-lists.ts";
+
+export const detector: Detector = requirementLists;

package/src/detectors/registry/return-type.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { returnType } from "../return-type.ts";
+
+export const detector: Detector = returnType;

package/src/detectors/requirement-lists.ts

@@ -0,0 +1,65 @@
+// required-listed-as-preferred: the same skill under a required heading or label and again under a preferred one
+// (structure/requirement-lists.ts). The headings and labels are requirement-heading's; the length of experience is read
+// with requirement-length-unit, requirement-length-word and number-word; requirement-item-ending ends an item.
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { requiredListedAsPreferred, type RequirementBlock, type RequirementWords, type ValuedWord } from "../structure/requirement-lists.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const valuedOf = (doc: ProseDocument, lexicon: string, group?: string): ValuedWord[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.weight === undefined || (group !== undefined && entry.group !== group) ? [] : [{ word: entry.pattern, value: entry.weight }],
+  );
+
+const wordsOf = (doc: ProseDocument): RequirementWords => ({
+  required: patternsOf(doc, "requirement-heading", "required"),
+  preferred: patternsOf(doc, "requirement-heading", "preferred"),
+  units: valuedOf(doc, "requirement-length-unit"),
+  before: patternsOf(doc, "requirement-length-word", "before"),
+  after: patternsOf(doc, "requirement-length-word", "after"),
+  numbers: valuedOf(doc, "number-word", "digit"),
+  endings: patternsOf(doc, "requirement-item-ending"),
+});
+
+const LIST_MARKER = /^\s*(?:[-*+・•]|\d+[.)．）])\s+(?:\[[ xX]\]\s+)?/u;
+
+const headingsOf = (doc: ProseDocument): RequirementBlock[] =>
+  doc.sections
+    .filter((section) => section.depth > 0)
+    .map((section) => ({ kind: "heading", depth: section.depth, text: section.heading, offset: section.span.start }));
+
+/** An item's own lines, joined, without its marker: the lines it wraps onto, up to a nested item. */
+const itemText = (written: string): string => {
+  const [first = "", ...rest] = written.split("\n");
+  const nested = rest.findIndex((line) => LIST_MARKER.test(line));
+  return [first.replace(LIST_MARKER, ""), ...(nested === -1 ? rest : rest.slice(0, nested))].map((line) => line.trim()).join(" ");
+};
+
+const itemsOf = (doc: ProseDocument): RequirementBlock[] =>
+  doc.lists.flatMap((list) => list.itemSpans.map((span) => ({ kind: "item", text: itemText(doc.source.slice(span.start, span.end)), offset: span.start })));
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => offset >= span.start && offset < span.end);
+
+/** The lines outside lists, with code, headings and emphasis marks blanked out: the places a label (必須：) stands alone. */
+const linesOf = (doc: ProseDocument): RequirementBlock[] => {
+  const prose = doc.prose ?? doc.source;
+  const starts = [0, ...[...prose.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.flatMap((start) => {
+    const line = prose.slice(start, prose.indexOf("\n", start) === -1 ? prose.length : prose.indexOf("\n", start));
+    return line.trim() === "" || inside(start, doc.listSpans) ? [] : [{ kind: "line", text: line, offset: start }];
+  });
+};
+
+export const requirementLists: Detector = (doc): Finding[] => {
+  const blocks = [...headingsOf(doc), ...linesOf(doc), ...itemsOf(doc)].toSorted((left, right) => left.offset - right.offset);
+  return requiredListedAsPreferred(blocks, wordsOf(doc)).map((issue) => ({
+    rule: "required-listed-as-preferred",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/return-type.ts

@@ -0,0 +1,30 @@
+// return-type-mismatch: one function's return type stated two ways on a page, the signature against a "Returns:" line, a
+// table's return column or a sentence (return-type.ts). The words come from the return-label, return-verb, return-subject,
+// return-type-word, return-clause and return-item lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { returnTypeClashes, type ReturnWords } from "../return-type.ts";
+import type { Detector, Finding, Lexicon } from "../plugin.ts";
+
+const patterns = (lexicon: Lexicon | undefined): string[] => (lexicon ?? []).map((entry) => entry.pattern);
+
+const kindsOf = (lexicon: Lexicon | undefined): Map<string, string> =>
+  new Map((lexicon ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
+
+const wordsOf = (lexicons: Readonly<Record<string, Lexicon>>): ReturnWords => ({
+  labels: patterns(lexicons["return-label"]),
+  verbs: patterns(lexicons["return-verb"]),
+  subjects: patterns(lexicons["return-subject"]),
+  kinds: kindsOf(lexicons["return-type-word"]),
+  clauses: patterns(lexicons["return-clause"]),
+  items: patterns(lexicons["return-item"]),
+});
+
+export const returnType: Detector = (doc): Finding[] =>
+  returnTypeClashes(doc.source, wordsOf(doc.lexicons)).map((clash) => ({
+    rule: "return-type-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, clash.offset),
+    values: { function: clash.fn, stated: clash.stated, signature: clash.signature, offset: clash.offset },
+  }));

package/src/detectors/structure-tree.ts

@@ -9,6 +9,7 @@ import { totalMismatches, type Amount } from "../structure/total.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { afterLabel } from "../structure/stated-period.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -227,11 +228,21 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
+/** その位置が、期間の語（period-label）で始まる行の、語より後ろにあるか。 */
+const labelledAt =
+  (doc: ProseDocument) =>
+  (offset: number): boolean => {
+    const lineStart = doc.source.lastIndexOf("\n", offset - 1) + 1;
+    const lineEnd = doc.source.indexOf("\n", offset);
+    const after = afterLabel(doc.source.slice(lineStart, lineEnd === -1 ? doc.source.length : lineEnd), patternsOf(doc, "period-label"));
+    return after !== undefined && offset >= lineStart + after;
+  };
+
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
 export const dateRangeReversed: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return reversedRanges(doc.source, dates, rangeWordsOf(doc))
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc))
     .filter((issue) => {
       const start = dateAt(dates, issue.offset);
       return !quotedDates(doc, dates[start], dates[start + 1]);

package/src/detectors/time-order.ts

@@ -3,11 +3,13 @@ import type { StructureIssue } from "../structure/issues.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { clockTimes } from "../compare/clock-time.ts";
 import { secondsOf, type DateSpan, type Mark, type TimeSpan, type TimeWords } from "../structure/time-marks.ts";
-import { timeOrderBreaks } from "../structure/time-order.ts";
-import { arrivalsBeforeDeparture } from "../structure/leg-times.ts";
+import { scheduleDays, timeOrderBreaks } from "../structure/time-order.ts";
+import { arrivalOffsets, arrivalsBeforeDeparture } from "../structure/leg-times.ts";
+import { shortConnections, type TravelLength, type TravelWords } from "../structure/connection-times.ts";
+import { timeLengths } from "../derived/time-lengths.ts";
 import { quoteAt } from "./structure-tree.ts";
 
-// 一日の予定の時刻の順番（time-order）と、発より前の着（arrival-before-departure）。時刻は compare/clock-time.ts が読み、
+// 一日の予定の時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
 // 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
 
 const marksOf = (doc: ProseDocument, lexicon: string): Mark[] =>
@@ -29,13 +31,13 @@ const datesOf = (doc: ProseDocument): DateSpan[] =>
 
 const timesOf = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
 
-type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords) => StructureIssue[];
+type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords, doc: ProseDocument) => StructureIssue[];
 
 /** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
 const detectorOf =
   (rule: string, find: Finder): Detector =>
   (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc)).map((issue) => ({
+    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => ({
       rule,
       severity: "warning",
       line: 0,
@@ -47,3 +49,36 @@ const detectorOf =
 
 export const timeOrder: Detector = detectorOf("time-order", timeOrderBreaks);
 export const arrivalBeforeDeparture: Detector = detectorOf("arrival-before-departure", arrivalsBeforeDeparture);
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
+
+/** 時間と分の長さ（約10分、about 40 minutes）。単位は unit-time の重さ（秒）で時間と分に分ける。 */
+const travelLengthsOf = (doc: ProseDocument): TravelLength[] =>
+  timeLengths(doc.source, {
+    hourUnits: patternsOf(doc, "unit-time", SECONDS_PER_HOUR),
+    minuteUnits: patternsOf(doc, "unit-time", SECONDS_PER_MINUTE),
+    halves: patternsOf(doc, "length-half"),
+    numberWords: patternsOf(doc, "count-number"),
+  });
+
+const travelWordsOf = (doc: ProseDocument): TravelWords => {
+  const marks = marksOf(doc, "travel-time-word");
+  return { cues: marks.filter((mark) => mark.group === "travel"), bounds: marks.filter((mark) => mark.group === "bound") };
+};
+
+export const connectionTimeShort: Detector = detectorOf("connection-time-short", (source, times, dates, words, doc) =>
+  shortConnections({
+    source,
+    times,
+    dates,
+    words,
+    travel: travelWordsOf(doc),
+    lengths: travelLengthsOf(doc),
+    arrivals: arrivalOffsets(source, times, dates, words),
+    days: scheduleDays(source, times, dates, words),
+  }),
+);

package/src/detectors/undefined-term.ts

@@ -6,6 +6,7 @@
 import { definedTerms } from "../structure/definition-use.ts";
 import { prefixGroupsOf, prefixVariants } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { capitalisedTerms, namedWords, readableText, setApartSpans, type Defined } from "./capitalised-term.ts";
 import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
 
 export type UndefinedTerm = { readonly offset: number; readonly term: string };
@@ -89,15 +90,31 @@ const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
   values: { term: use.term, offset: use.offset },
 });
 
+const NAME_LISTS = ["proper-name-word", "place-region", "calendar-name", "month-name", "company-form", "party-role"] as const;
+
+/** Capitalised terms, for a language whose package lists the words that join one name (name-joiner); Japanese has none. */
+const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token[])[], defined: readonly Defined[]): UndefinedTerm[] => {
+  if (doc.lexicons["name-joiner"] === undefined) return [];
+  const words = {
+    names: NAME_LISTS.flatMap((id) => patternsOf(doc, id)),
+    divisions: patternsOf(doc, "numbered-division"),
+    joiners: patternsOf(doc, "name-joiner"),
+  };
+  const marked = [...(doc.markup?.headings ?? []), ...doc.links, ...setApartSpans(doc.source)];
+  return capitalisedTerms({ source: doc.source, readable: readableText(doc.source), sentences, defined, named: namedWords(doc.source), marked, words });
+};
+
 export const undefinedTerm: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const prefixEntries = doc.lexicons["defined-term-prefix"] ?? [];
   const sentences = doc.sentences.map((sentence) => sentence.tokens ?? []);
-  const defined = definedTerms(doc.structure).map((term) => term.term);
-  return undefinedTerms(doc.source, sentences, defined, {
+  const definitions = definedTerms(doc.structure);
+  const defined = definitions.map((term) => term.term);
+  const prefixed = undefinedTerms(doc.source, sentences, defined, {
     prefixes: prefixEntries.map((entry) => entry.pattern),
     prefixGroups: prefixGroupsOf(prefixEntries),
     selfNouns: [...patternsOf(doc, "self-reference-noun"), ...patternsOf(doc, "document-kind")],
     isQuoted: (term) => QUOTE_PAIRS.some(([open, close]) => doc.source.includes(`${open}${term}${close}`)),
-  }).map((use) => findingOf(doc, use));
+  });
+  return [...prefixed, ...capitalisedUses(doc, sentences, definitions)].map((use) => findingOf(doc, use));
 };

package/src/document.ts

@@ -25,6 +25,7 @@ import { cutTextSpans } from "./span-cut.ts";
 import { markdownFigures } from "./text-figures.ts";
 import { documentMarkup } from "./markup.ts";
 import { BARE_URL } from "./bare-url.ts";
+import { lazyCells, tableCellsOf } from "./table-cells.ts";
 import type { BulletList, LanguageAdapter, Markup, Paragraph, ProseDocument, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 /**
@@ -355,7 +356,7 @@ const documentOf = (path: string, source: string, adapter: LanguageAdapter, team
     markdown,
     profile,
   }));
-  return {
+  const doc: ProseDocument = {
     path,
     source,
     language: adapter.id,
@@ -381,7 +382,9 @@ const documentOf = (path: string, source: string, adapter: LanguageAdapter, team
     get markup(): Markup {
       return documentMarkup(root, source, markdown, [...emailLayout.replyQuotes, ...syntax]);
     },
+    tableCells: lazyCells(() => tableCellsOf(doc, (text) => adapter.segment(text))),
   };
+  return doc;
 };
 
 /**

package/src/facts/table-facts.ts

@@ -69,3 +69,6 @@ export const tableFacts = (source: string, values: readonly FactValue[]): Fact[]
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
     return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
   });
+
+/** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */
+export const tableBodyCells = (source: string): Cell[] => tablesOf(linesOf(source)).flatMap((table) => table.rows.flatMap(cellsOf));

package/src/name-variants.ts

@@ -1,6 +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）、読みが同じ（山田太郎 と 山田太朗）、
@@ -19,7 +20,11 @@ export type NameMention = {
   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>;
@@ -99,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;
@@ -283,6 +343,20 @@ 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("");
 
@@ -344,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/plugin.ts

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