chaffjs 0.34.0 → 0.35.0

package/src/detectors/due-date.ts

@@ -4,7 +4,8 @@
 // order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end,
 // or from its start in the group a dated-span-label entry names;
 // a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label;
-// a signature line giving a pair's later date, from the role words of dated-signer-label);
+// a signature line giving a pair's later date, from the role words of dated-signer-label;
+// a pair's label naming a version, End of support for 5.0.0 or 3.0.0 のサポート終了日, from dated-pair-version-word);
 // the dates are the structure tree's, and the lines are read with code masked.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
@@ -15,6 +16,7 @@ import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { periodWordsOf } from "./range-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import type { VersionWords } from "../structure/versioned-label.ts";
 import { readableDates, withReadableDates } from "./readable-dates.ts";
 
 /** A record's facts table can sit well below its header date (a listing date above the table holding the move-in date). */
@@ -37,6 +39,12 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
   minutes: patternsOf(doc, "minutes-title-word"),
 });
 
+const versionWordsOf = (doc: ProseDocument): VersionWords => {
+  const entries = doc.lexicons["dated-pair-version-word"] ?? [];
+  const at = (position: "before" | "after"): string[] => entries.filter((entry) => entry.position === position).map((entry) => entry.pattern);
+  return { after: at("after"), before: at("before") };
+};
+
 const orderAsidesOf = (doc: ProseDocument): string[] => [...patternsOf(doc, "deadline-passed-word"), ...patternsOf(doc, "date-now-word")];
 
 const treeDates = (tree: NonNullable<ProseDocument["structure"]>): OrderDate[] =>
@@ -70,6 +78,7 @@ export const dueDate: Detector = (doc): Finding[] => {
       spans,
       whole: doc.source,
       signers: doc.lexicons["dated-signer-label"] ?? [],
+      versions: versionWordsOf(doc),
     }).map((issue) => findingOf(doc, issue, variantOf(issue))),
     ...columnDatesOutOfOrder(text, dates, [...pairs, ...(doc.lexicons["dated-column-label"] ?? [])], orderAsidesOf(doc)).map((issue) =>
       findingOf(doc, issue, "order"),

package/src/detectors/en-shape.ts

@@ -1,6 +1,7 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
 import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
+import { namesWrittenMidSentence } from "./heading-names.ts";
 import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -137,7 +138,10 @@ const headingsOf = (sections: readonly Section[], fixedCase: ReadonlySet<string>
  * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const fixedCase = new Set(FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)));
+  const fixedCase = new Set([
+    ...FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+    ...namesWrittenMidSentence(doc.sentences.map((sentence) => sentence.text)),
+  ]);
   const pageTitle = pageTitleOf(doc.sections);
   const judged = headingsOf(
     doc.sections.filter((section) => section !== pageTitle),

package/src/detectors/fact-consistency.ts

@@ -140,9 +140,10 @@ const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
   );
   const read = new Set([...termed, ...labelled.map((fact) => fact.value.start)]);
   const verbs = verbQuantityFacts(doc.source, values, verbQuantityWordsOf(doc)).filter((fact) => !read.has(fact.value.start));
-  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons));
+  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons), { columnGroups: true });
   const facts = withQualifiedKeys(doc, [...labelled, ...terms, ...verbs, ...tabled]);
-  return withCellKeys(scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading")), qualifierWordsOf(doc));
+  const scoped = scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading"), { paragraphHeads: true });
+  return withCellKeys(scoped, qualifierWordsOf(doc));
 };
 
 /** 文書の名前付きの値。二つの rule が読むので、文書ごとに一度だけ読む。 */

package/src/detectors/gram-passages.ts

@@ -0,0 +1,36 @@
+import type { Section, Sentence } from "../plugin.ts";
+
+/**
+ * 問いの印で終わる見出し。後ろに括弧の注記（(updated Nov. 14, 2024)）が付いてもよい。
+ * 「Q1」の札だけでは問いと見ない。四半期（Q1 2024）の見出しと見分けられない。
+ */
+const QUESTION_END = /[?？]\s*(?:[(（][^()（）]*[)）])?$/u;
+
+export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
+
+/** 範囲を決めるのに見るのは、見出しと深さと文だけ。 */
+type Heading = Pick<Section, "depth" | "heading" | "sentences">;
+
+type Answer = { readonly depth: number; readonly sentences: Sentence[] };
+type Passages = { readonly rest: Sentence[]; readonly answers: Answer[]; readonly open: readonly Answer[] };
+
+/** 節は、それを囲む一番内側の問いの答えに入る。同じ深さか浅い見出しが来れば、その問いは閉じている。 */
+const place = (passages: Passages, section: Heading): Passages => {
+  const open = passages.open.filter((answer) => answer.depth < section.depth);
+  if (isQuestionHeading(section.heading)) {
+    const answer = { depth: section.depth, sentences: [...section.sentences] };
+    return { ...passages, answers: [...passages.answers, answer], open: [...open, answer] };
+  }
+  const owner = open.at(-1);
+  (owner?.sentences ?? passages.rest).push(...section.sentences);
+  return { ...passages, open };
+};
+
+/**
+ * 言い回しを数える範囲。問いの見出しの下（より深い見出しの「A1」も含む）はそれぞれ一つの答えで、読み手は答えを一つずつ読む。
+ * 別の答えで同じ案内（〜をご覧ください）を繰り返しても、書き手が言い直したのではない。問いでない節は、文書全体で一つの範囲。
+ */
+export const gramPassagesOf = (sections: readonly Heading[]): Sentence[][] => {
+  const passages = sections.reduce<Passages>(place, { rest: [], answers: [], open: [] });
+  return [passages.rest, ...passages.answers.map((answer) => answer.sentences)].filter((sentences) => sentences.length > 0);
+};

package/src/detectors/heading-end-mark.ts

@@ -39,8 +39,21 @@ export const endMarkOf = (heading: string, words: readonly string[] = []): strin
 
 type Judged = { readonly heading: MarkupHeading; readonly mark: string };
 
-/** The odd ones among headings of one depth, each with the usual side's first heading and count. */
-const oddAtDepth = (doc: ProseDocument, judged: readonly Judged[]): Finding[] => {
+const LOWER_CASE = /\p{Ll}/u;
+/** A word of this many capitals is a word set in capitals, not only an acronym (AGENCY, DATES; not FAQ). */
+const CAPITALS_WORD = /\p{Lu}{4,}/u;
+
+/**
+ * Whether a heading is set in capitals ("AGENCY:", "FOR FURTHER INFORMATION CONTACT:"). A notice's captions are one kind of
+ * heading and its sections in ordinary case ("Footnotes") another, so the two are compared apart.
+ */
+export const isCapitalsHeading = (heading: string): boolean => !LOWER_CASE.test(heading) && CAPITALS_WORD.test(heading);
+
+/** Headings compared with one another: the same depth, and the same case (capitals or ordinary). */
+const kindOf = (entry: Judged): string => `${String(entry.heading.depth)}:${String(isCapitalsHeading(entry.heading.text))}`;
+
+/** The odd ones among headings of one kind, each with the usual side's first heading and count. */
+const oddOfKind = (doc: ProseDocument, judged: readonly Judged[]): Finding[] => {
   if (judged.length < MIN_HEADINGS) return [];
   const odd = minorityWithin(judged, (entry) => entry.mark !== "", MINORITY_PERCENT);
   const usual = judged.filter((entry) => !odd.includes(entry));
@@ -56,9 +69,9 @@ const oddAtDepth = (doc: ProseDocument, judged: readonly Judged[]): Finding[] =>
 };
 
 /**
- * Headings that end with a colon or a full stop where most headings of the same depth do not, or the other way round. Headings
- * of one depth are one kind of heading; a depth of labels ("Optional:") is its own way. The page title (one top-level heading
- * that opens the document) is a name and is not compared.
+ * Headings that end with a colon or a full stop where most headings of the same depth and case do not, or the other way round.
+ * Headings of one depth are one kind of heading; a depth of labels ("Optional:") is its own way, and so are captions set in
+ * capitals. The page title (one top-level heading that opens the document) is a name and is not compared.
  */
 export const headingEndMark: Detector = (doc, options): Finding[] => {
   const words = (options.lexicon ?? []).map((entry) => entry.pattern);
@@ -70,12 +83,12 @@ export const headingEndMark: Detector = (doc, options): Finding[] => {
       const mark = endMarkOf(heading.text, words);
       return mark === undefined ? [] : [{ heading, mark }];
     });
-  const depths = [...new Set(judged.map((entry) => entry.heading.depth))];
-  return depths
-    .flatMap((depth) =>
-      oddAtDepth(
+  const kinds = [...new Set(judged.map(kindOf))];
+  return kinds
+    .flatMap((kind) =>
+      oddOfKind(
         doc,
-        judged.filter((entry) => entry.heading.depth === depth),
+        judged.filter((entry) => kindOf(entry) === kind),
       ),
     )
     .toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));

package/src/detectors/heading-names.ts

@@ -0,0 +1,31 @@
+import { straightApostrophes } from "../orthography.ts";
+
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+const POSSESSIVE = /'s$/u;
+/** 番号が続く語（Example 4、Layer 1）は番号の札で、名前ではない。札の語は流儀によらず大文字で書く。 */
+const NUMBER_FOLLOWS = /^\s+\d/u;
+/** 引用符の中（"Wakayama's Food Ingredients and Food Culture"）は題名や人の言葉で、題の語は名前でなくても大文字になる。 */
+const QUOTE_MARK = /[“”]/gu;
+
+const outsideQuotes = (text: string): string =>
+  text
+    .replace(QUOTE_MARK, '"')
+    .split('"')
+    .filter((_, index) => index % 2 === 0)
+    .join(" ");
+
+const startsUpper = (word: string): boolean => /^[A-Z]/u.test(word);
+
+const midSentenceNames = (sentence: string): string[] =>
+  [...outsideQuotes(straightApostrophes(sentence)).matchAll(WORD)]
+    .slice(1)
+    .filter((match) => startsUpper(match[0]) && !NUMBER_FOLLOWS.test(match.input.slice(match.index + match[0].length)))
+    .map((match) => match[0].replace(POSSESSIVE, ""));
+
+/**
+ * 文書が文の途中で大文字で書く語（NOAA、Flood Inundation Mapping、Alaska）。固有の名前なので、見出しに出ても
+ * どちらの流儀でも大文字のまま。見出しの流儀の証拠に数えないよう、所有格の形（NOAA's）も添えて返す。
+ * 文の頭の語は、名前でなくても大文字になるので数えない。
+ */
+export const namesWrittenMidSentence = (sentences: readonly string[]): ReadonlySet<string> =>
+  new Set(sentences.flatMap(midSentenceNames).flatMap((name) => [name, `${name}'s`]));

package/src/detectors/heading-numbering.ts

@@ -1,6 +1,6 @@
 import type { Detector, Finding, LexiconEntry } from "../plugin.ts";
 import { findingAt, writtenHeadings } from "./markup-finding.ts";
-import { numberingMinorities, numberingStyleOf, UNNUMBERED, type NumberingMinority, type NumberLabel } from "../heading-numbering.ts";
+import { numberingMinorities, numberingStyleOf, opensNumbering, UNNUMBERED, type NumberingMinority, type NumberLabel } from "../heading-numbering.ts";
 
 const labelsOf = (entries: readonly LexiconEntry[]): NumberLabel[] =>
   entries.map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
@@ -28,7 +28,12 @@ export const headingNumbering: Detector = (doc): Finding[] => {
   const labels = labelsOf(doc.lexicons["heading-number-label"] ?? []);
   const matter = (doc.lexicons["unnumbered-heading"] ?? []).map((entry) => entry.pattern.toLowerCase());
   const styles = headings.map((heading) => numberingStyleOf(heading.text, labels));
-  const read = headings.map((heading, at) => ({ depth: heading.depth, style: styles[at] ?? UNNUMBERED, skipped: isFrontOrBackMatter(heading.text, matter) }));
+  const read = headings.map((heading, at) => ({
+    depth: heading.depth,
+    style: styles[at] ?? UNNUMBERED,
+    skipped: isFrontOrBackMatter(heading.text, matter),
+    opens: opensNumbering(heading.text, labels),
+  }));
   return numberingMinorities(read).flatMap((minority) => {
     const heading = headings[minority.at];
     if (heading === undefined) return [];

package/src/detectors/inch-mark.ts

@@ -0,0 +1,49 @@
+/**
+ * A curly double quote written as the inch mark: a decimal number, then the mark, then a unit (".015 “Hg/hr",
+ * "29.92”Hg"). It quotes nothing, so it opens and closes nothing. text is the section, offset the mark's position.
+ */
+
+/**
+ * A number with a decimal part right before the mark, with at most one space between. A year or a count never has one,
+ * so "In 1969 “Hurricane Camille struck" stays an unclosed quote.
+ */
+const DECIMAL_BEFORE = /\.\p{Nd}+[ \u00A0]?$/u;
+
+/** A short run of letters right after the mark: the unit (Hg, in). */
+const UNIT_AFTER = /^\p{L}{1,3}(?!\p{L})/u;
+
+const LOOK_AROUND = 40;
+const OPENING = "\u201C";
+const CLOSING = "\u201D";
+
+/** Where the paragraph holding offset ends: the next blank line, or the end of the text. */
+const paragraphEnd = (text: string, offset: number): number => {
+  const blank = /\n[ \t\u3000]*\n/u.exec(text.slice(offset));
+  return blank === null ? text.length : offset + blank.index;
+};
+
+const betweenNumberAndUnit = (text: string, offset: number): boolean =>
+  DECIMAL_BEFORE.test(text.slice(Math.max(0, offset - LOOK_AROUND), offset)) && UNIT_AFTER.test(text.slice(offset + 1, offset + 1 + LOOK_AROUND));
+
+/** A closing mark in rest that is not taken by an opening mark written after the start of rest. */
+const closesEarlier = (rest: string): boolean => {
+  const depth = { open: 0, closed: false };
+  [...rest].forEach((mark) => {
+    if (depth.closed) return;
+    if (mark === OPENING) depth.open += 1;
+    else if (mark === CLOSING && depth.open === 0) depth.closed = true;
+    else if (mark === CLOSING) depth.open -= 1;
+  });
+  return depth.closed;
+};
+
+/**
+ * The mark at offset is an inch mark. An opening mark is one only when nothing in its paragraph closes it ("at 2.5
+ * “Hg” quotes something); a closing mark only when no quote is open.
+ */
+export const isInchMark = (text: string, offset: number, quoteOpen: boolean): boolean => {
+  const mark = text.charAt(offset);
+  if ((mark !== OPENING && mark !== CLOSING) || !betweenNumberAndUnit(text, offset)) return false;
+  if (mark === CLOSING) return !quoteOpen;
+  return !closesEarlier(text.slice(offset + 1, paragraphEnd(text, offset)));
+};

package/src/detectors/lexicon.ts

@@ -1,4 +1,5 @@
 import { joinWords } from "./word-list.ts";
+import { pairMinority } from "./contraction-minority.ts";
 import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
@@ -68,7 +69,6 @@ const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density", "at-floor");
 /** 語彙表の語の密度だけを見る rule が共通で使う。rule の id は実行側が入れる。 */
 export const phraseDensity = densityRule("");
-export const vagueDensity = densityRule("vague-word-density");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
@@ -258,40 +258,51 @@ export const aiTell: Detector = (doc, options): Finding[] => {
  * **どちらが正しいかは決めない。** 短縮形を使うかどうかは文体の選択で、
  * 立場を取ると方針の違う書き手に rule ごと無視される。spec §12.3。
  *
- * 語彙表は対を持つ（`pattern` と `instead_of`）。片方だけを数えても、
- * 意図した硬い文体なのか不統一なのかが分からない。
+ * 語彙表は対を持つ（`pattern` と `instead_of`）。比べるのは対の中だけで、別の語どうしは比べない。
+ * GOV.UK の文体は「you're」を使い否定は「do not」と書く。語ごとに決めた書きかたで、混在ではない。
+ * 否定と代名詞＋動詞の族にもまとめない。「don't」と「does not」を書き分ける文書もある。
  */
 /**
  * 語の境界で照合する。部分一致だと「it isn't」が「it is」を含んでしまい、
  * 短縮形を使っている文が「使っていない」側に数えられる。
  */
-const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
+const wordUses = (text: string, word: string): number => [...text.matchAll(new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "gu"))].length;
 
-/** アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。 */
-const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).toLowerCase();
+const containsWord = (text: string, word: string): boolean => wordUses(text, word) > 0;
+
+/**
+ * アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。
+ * 折り返した行（「do」で改行して「not」）も、空白 1 つと同じに読む。
+ */
+const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).replace(/\s+/gu, " ").toLowerCase();
+
+type MixedPair = { readonly minority: string; readonly majority: string; readonly count: number };
+
+const mixedPair = (body: string, short: string, long: string): MixedPair | undefined => {
+  const uses = { short: wordUses(body, short), long: wordUses(body, long) };
+  const side = pairMinority(uses);
+  if (side === undefined) return undefined;
+  return side === "short" ? { minority: short, majority: long, count: uses.short } : { minority: long, majority: short, count: uses.long };
+};
 
 export const contractionMix: Detector = (doc, options): Finding[] => {
-  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
-  const body = doc.sentences.map(comparableText).join(" ");
-  const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
-  const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
-  // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
-  if (used.length === 0 || spelled.length === 0) return [];
-  const minorityIsShort = used.length <= spelled.length;
-  const few = minorityIsShort ? used : spelled;
-  if (few.length > options.limit) return [];
-  const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
+  // 文は改行でつなぐ。空白でつなぐと、箇条書きの「What we do」と次の項目「not every…」が「do not」と数えられる。
+  const body = doc.sentences.map(comparableText).join("\n");
+  const mixed = (options.lexicon ?? []).flatMap((entry) => {
+    const pair = entry.instead_of === undefined ? undefined : mixedPair(body, entry.pattern.toLowerCase(), entry.instead_of.toLowerCase());
+    return pair === undefined || pair.count > options.limit ? [] : [pair];
+  });
   const hits = doc.sentences.flatMap((sentence) => {
     const text = comparableText(sentence);
-    const matched = wanted.find((word) => containsWord(text, word));
-    return matched === undefined ? [] : [{ sentence, matched }];
+    const pair = mixed.find((candidate) => containsWord(text, candidate.minority));
+    return pair === undefined ? [] : [{ sentence, pair }];
   });
-  return hits.map((hit) => ({
+  return hits.map(({ sentence, pair }) => ({
     rule: "contraction-consistency",
     severity: "info",
     line: 0,
     column: 0,
-    quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: few.length, limit: options.limit, offset: hit.sentence.span.start },
+    quote: sentence.text.trim(),
+    values: { matched: pair.minority, majority: pair.majority, count: pair.count, limit: options.limit, offset: sentence.span.start },
   }));
 };

package/src/detectors/mark-shape.ts

@@ -2,6 +2,7 @@ import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plu
 import { escapeRegExp } from "../orthography.ts";
 import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { captionsOf, isCaptionAt } from "./caps-caption.ts";
 
 /** The letters a mark must touch to count as part of the document's text, by language. */
 const SCRIPT: Readonly<Record<string, RegExp>> = {
@@ -41,12 +42,15 @@ const besideLetter = (text: string, at: number, step: number, script: RegExp): b
 
 const touchesScript = (text: string, at: number, script: RegExp): boolean => besideLetter(text, at, -1, script) || besideLetter(text, at, 1, script);
 
-/** The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side. */
-export const marksIn = (sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
+/**
+ * The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side.
+ * The letters beside a mark are read in the source, so a mark that opens a sentence (。(2）当社) counts wherever the sentence starts.
+ */
+export const marksIn = (source: string, sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
   const quoted = quotedSpans(sentence.text);
   return sentence.text.split("").flatMap((char, at) => {
     const form = forms.get(char);
-    if (form === undefined || !touchesScript(sentence.text, at, script)) return [];
+    if (form === undefined || !touchesScript(source, sentence.span.start + at, script)) return [];
     if (isWithinAny(quoted, { start: at, end: at })) return [];
     return [{ sentence, char, form, offset: sentence.span.start + at, spaced: form.side }];
   });
@@ -88,7 +92,7 @@ export const markConsistency: Detector = (doc, options): Finding[] => {
   const script = SCRIPT[doc.language];
   if (script === undefined) return [];
   const forms = formsOf(options.lexicon ?? []);
-  const marks = ownSentences(doc).flatMap((sentence) => marksIn(sentence, forms, script));
+  const marks = ownSentences(doc).flatMap((sentence) => marksIn(doc.source, sentence, forms, script));
   const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
   return kinds.flatMap((kind) =>
     minorityFindings(
@@ -210,10 +214,12 @@ export const isShouting = (run: string, known: ReadonlySet<string>, conventional
   return long.length >= MIN_LONG_WORDS && ordinary.length * 2 > words.length;
 };
 
-/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"). */
+/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"), and not a caption or a mention of one. */
 export const capsShouting: Detector = (doc, options): Finding[] => {
   const known = lowerCaseWords(doc.prose ?? doc.source);
   const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
-  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional));
+  const captions = captionsOf(doc.source);
+  const isCaption = (hit: Hit): boolean => captions.has(hit.matched) || isCaptionAt(doc.source, hit.offset, hit.offset + hit.matched.length);
+  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional) && !isCaption(hit));
   return reportFrom(hits, options.limit);
 };

package/src/detectors/name-variant-apart.ts

@@ -0,0 +1,63 @@
+import type { ProseDocument, Token } from "../plugin.ts";
+import { nameKey, type NameMention } from "../name-variants.ts";
+import { companyGroupBases, type CompanyMention } from "../company-names.ts";
+import type { OrderName } from "../name-word-order.ts";
+import { isInCapitalsPassage } from "../capitals-passage.ts";
+import { givenNameBefore } from "../name-given-before.ts";
+import { definedTerms } from "../structure/definition-use.ts";
+
+// name-variant が、似た形でも別のものと見る所。大文字で書いた一節、名の違う二人、会社のグループの一社ずつ、定義した語、同じ文に
+// 並べた二つ。
+
+/** 大文字で書いた一節（契約書の免責の段落、大文字の見出し）の中の名前（eGAIN SYSTEM）。その節の大文字で、名前の書き方ではない。 */
+export const outsideCapitals = <Mention extends { readonly offset: number; readonly surface: string }>(
+  prose: string,
+  mentions: readonly Mention[],
+): Mention[] => mentions.filter((mention) => !isInCapitalsPassage(prose, mention.offset, mention.offset + mention.surface.length));
+
+/** 名前に、すぐ前に書いた名（Jeffrey D. Walker の Jeffrey）を付ける。tokens は文書の順の語。 */
+export const withGivenNames = (tokens: readonly Token[], source: string, mentions: readonly NameMention[]): NameMention[] => {
+  const startAt = new Map(tokens.map((token, index) => [token.span.start, index]));
+  return mentions.map((mention) => {
+    const index = startAt.get(mention.offset);
+    const givenName = index === undefined ? undefined : givenNameBefore(tokens, index, source);
+    return givenName === undefined ? mention : { ...mention, givenName };
+  });
+};
+
+/**
+ * 会社のグループ（companyGroupBases）の一社の名前どうし（GitLab Ltd (UK) と GitLab LTD (Ireland)）か。形の語の書き方の違いも、
+ * 別の会社を言い分けている。forms は会社の形の語（Inc、Ltd）。
+ */
+export const isGroupPairOf = (
+  companies: readonly CompanyMention[],
+  forms: readonly string[],
+): ((found: { readonly name: string; readonly usual: string }) => boolean) => {
+  const groups = [...companyGroupBases(companies)];
+  const formKeys = forms.map(nameKey);
+  const isGroupName = (surface: string): boolean => {
+    const key = nameKey(surface);
+    return groups.some((base) => formKeys.some((form) => key === base + form));
+  };
+  return ({ name, usual }) => isGroupName(name) && isGroupName(usual);
+};
+
+/** 位置を含む文の番号。文の外（見出し、表）は、その前の文の番号。 */
+export const sentenceIndexOf = (doc: ProseDocument): ((offset: number) => number) => {
+  const starts = doc.sentences.map((sentence) => sentence.span.start);
+  const search = (offset: number, low: number, high: number): number => {
+    if (low >= high) return low - 1;
+    const middle = Math.floor((low + high) / 2);
+    return (starts[middle] ?? 0) <= offset ? search(offset, middle + 1, high) : search(offset, low, middle);
+  };
+  return (offset) => search(offset, 0, starts.length);
+};
+
+/**
+ * 文書が定義した語（“Company Subsidiary” means …）でない名前。定義した語は文書が作った呼び名で、同じ語を違う順に並べた所
+ * （Subsidiary of the Company）はその中身を書いたふつうの言い方。
+ */
+export const notDefinedTerms = (doc: ProseDocument, names: readonly OrderName[]): OrderName[] => {
+  const terms = new Set(doc.structure === undefined ? [] : definedTerms(doc.structure).map(({ term }) => term.toLowerCase()));
+  return names.filter((name) => !terms.has(name.surface.toLowerCase()));
+};

package/src/detectors/name-variant.ts

@@ -7,7 +7,7 @@ import { lookalikeSlipsIn, type LookalikeChars } from "../name-lookalike-chars.t
 import { givenNameReadingOf, readingOfWords, type CharReadings } from "../name-char-reading.ts";
 import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper, type PredicateEnds } from "../company-names.ts";
+import { companyMentionsIn, companyVariants, type CompanyForm, type CompanyMention, type IsProper, type PredicateEnds } from "../company-names.ts";
 import { kanaSpelledCompanies, type ReadWord } from "../company-kana-spelling.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
@@ -23,6 +23,7 @@ import { spacedPersonNamesIn } from "../spaced-person-name.ts";
 import { isOrdinaryToken, withOrdinaryWords } from "../name-ordinary-word.ts";
 import { isInPersonField } from "../person-field.ts";
 import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
+import { isGroupPairOf, notDefinedTerms, outsideCapitals, sentenceIndexOf, withGivenNames } from "./name-variant-apart.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -145,20 +146,22 @@ const predicateEndsOf = (doc: ProseDocument): PredicateEnds =>
 const readWordsOf = (doc: ProseDocument): ReadWord[] =>
   tokensOf(doc).map((token) => ({ start: token.span.start, end: token.span.end, surface: token.surface, reading: token.reading }));
 
+/** 会社の名前の現れ。大文字で書いた一節の中のものは除く。 */
+const companyMentionsOf = (doc: ProseDocument, prose: string): CompanyMention[] =>
+  outsideCapitals(prose, companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), kanaStopsOf(doc), predicateEndsOf(doc)));
+
 /**
  * 会社の名前の書き分けと、名前の漢字一字をその読みのかなで書いた所（みどり野 と みどりの）。名前の見方がすでに指した所と重なる
  * ものは除く。
  */
-const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
-  const stops = kanaStopsOf(doc);
-  const mentions = companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), stops, predicateEndsOf(doc));
+const companyFindings = (doc: ProseDocument, prose: string, mentions: readonly CompanyMention[], reported: readonly Reported[]): Reported[] => {
   const variants = companyVariants(mentions).map(({ mention, usual, kind }) => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
     kind: kind === "spelling" ? kind : `company-${kind}`,
   }));
-  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), stops.particles)
+  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), kanaStopsOf(doc).particles)
     .map(({ surface, offset, usual }) => ({ offset, name: surface, usual, kind: "company-kana" }))
     .filter((found) => !overlapsAny(variants, found.offset, found.name.length));
   return [...variants, ...kana].filter(({ offset, name }) => !overlapsAny(reported, offset, name.length));
@@ -207,6 +210,9 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
     .map((token) => ({ start: token.span.start, end: token.span.end, key: stemOf(token.surface, suffixes) }));
 };
 
+/** 語彙表 name-title-joiner の、前置詞の後ろにだけ立つ冠詞（the）の組。 */
+const ARTICLE = "article";
+
 /**
  * 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学）。名前と読める所は、括弧の中（name-quote）、大文字で始まる語の並び
  * （name-title-joiner を挟んでよい）、名前を書く欄の後ろ（name-label）。大文字の語の並びどうしは、片方が表の升まるごとに
@@ -214,13 +220,20 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
  */
 const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
   const starts = sentenceStartsOf(doc);
+  const joiners = doc.lexicons["name-title-joiner"] ?? [];
   const spans = [
     ...quotedSpans(prose, patternsOf(doc, "name-quote")),
-    ...titleCaseSpans(prose, patternsOf(doc, "name-title-joiner"), (offset) => starts.has(offset)),
+    ...titleCaseSpans(
+      prose,
+      joiners.filter((entry) => entry.group !== ARTICLE).map((entry) => entry.pattern),
+      (offset) => starts.has(offset),
+      joiners.filter((entry) => entry.group === ARTICLE).map((entry) => entry.pattern),
+    ),
     ...labelledSpans(prose, patternsOf(doc, "name-label")),
   ];
   const cells = new Set(tableBodyCells(proseAndTablesOf(doc)).map((cell) => cell.text.trim()));
-  return wordOrderVariants(orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)), cells)
+  const names = notDefinedTerms(doc, orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)));
+  return wordOrderVariants(names, cells, sentenceIndexOf(doc))
     .filter(({ name }) => !overlapsAny(reported, name.offset, name.surface.length))
     .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
 };
@@ -270,7 +283,7 @@ const tokenRunsOf = (sentence: Sentence): readonly (readonly Token[])[] => {
 const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars): NameMention[] => {
   const cues: NameCues = { leads: patternsOf(doc, "person-lead"), suffixes: patternsOf(doc, "person-suffix"), particles: patternsOf(doc, "name-particle") };
   const charReadings = charReadingsOf(doc);
-  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, doc.source, cues.suffixes, charReadings)));
+  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, prose, cues.suffixes, charReadings)));
   const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
   const cued = [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)].map((mention): NameMention => {
     const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
@@ -281,7 +294,7 @@ const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars):
   const outside = joined.filter(
     (mention) => !spaced.some((name) => name.offset < mention.offset + mention.surface.length && mention.offset < name.offset + name.surface.length),
   );
-  return withKnownNeighbours([...outside, ...spaced], prose).toSorted((left, right) => left.offset - right.offset);
+  return outsideCapitals(prose, withKnownNeighbours([...outside, ...spaced], prose)).toSorted((left, right) => left.offset - right.offset);
 };
 
 /** 人の名前で形の似た別の字（太 と 大）は語彙表 name-lookalike-char が組（group）ごとに言う。 */
@@ -352,10 +365,15 @@ const wordUseOf = (doc: ProseDocument): WordUse => {
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, nameMentionsOf(doc, prose, chars)));
+  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, withGivenNames(tokensOf(doc), doc.source, nameMentionsOf(doc, prose, chars))));
+  const companies = companyMentionsOf(doc, prose);
+  const inGroup = isGroupPairOf(
+    companies,
+    companyFormsOf(doc).map((form) => form.pattern),
+  );
   const variants = nameVariants(mentions, chars, spellingInputOf(doc), wordUseOf(doc))
     .map(({ mention, usual, kind }): Reported => ({ offset: mention.offset, name: mention.surface, usual, kind }))
-    .filter(notSpacingOnly);
+    .filter((found) => notSpacingOnly(found) && !inGroup(found));
   const lookalikes = lookalikeSlipsIn(mentions, lookalikeCharsOf(doc)).map(({ mention, usual }) => ({
     offset: mention.offset,
     name: mention.surface,
@@ -363,7 +381,7 @@ export const nameVariant: Detector = (doc): Finding[] => {
     kind: "lookalike",
   }));
   const names = [...variants, ...lookalikes.filter((found) => !overlapsAny(variants, found.offset, found.name.length))];
-  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, companies, names)];
   const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies).filter(notSpacingOnly)];
   const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
   const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];

package/src/detectors/numeral-word.ts

@@ -0,0 +1,33 @@
+/**
+ * 大文字の並びでも略語として書かれないもの。どれも字の形だけで決まる。
+ * - I だけのローマ数字（II、III）。名前の後ろでなくても番号で（Doswell, III、1964: II Structure）、この形の略語は使われない。
+ *   IV や VI のように V・X を含む数字は略語（静脈注射の IV）でもあるので、名前の番号（name-numeral.ts）の位置でだけ外す。
+ * - 大文字で始まる語に - で繋いだ I・V・X の数字（Association-IV）。名前の番号を空白でなく - で書いた形。
+ * - X を 3 つ以上並べた伏せ字（the Secretary of State for XXX）や X の数で書く染色体の型（XXX症候群）。KKK や WWW のような他の字の繰り返しは略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 略語の切り出しと同じ境目。日本語の文字（XXX症候群）は語の続きではない。
+const NOT_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const NOT_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+
+const ONES_NUMERAL = new RegExp(`${NOT_BEFORE}I{2,3}${NOT_AFTER}`, "gu");
+const MASK = new RegExp(`${NOT_BEFORE}X{3,}${NOT_AFTER}`, "gu");
+const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
+const JOINED_NUMERAL = new RegExp(String.raw`(?<![A-Za-z0-9_-])\p{Lu}\p{Ll}+-(?<numeral>${SMALL_NUMERAL})${NOT_AFTER}`, "gu");
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const joinedSpans = (text: string): Span[] =>
+  [...text.matchAll(JOINED_NUMERAL)].map((match) => {
+    const end = match.index + match[0].length;
+    return { start: end - (match.groups?.["numeral"] ?? "").length, end };
+  });
+
+/** 文の中の、番号か伏せ字と読む大文字の範囲。 */
+export const numeralWordSpans = (text: string): Span[] => [
+  ...[...text.matchAll(ONES_NUMERAL)].map(spanOf),
+  ...[...text.matchAll(MASK)].map(spanOf),
+  ...joinedSpans(text),
+];