chaffjs 0.33.0 → 0.35.0

package/src/detectors/heading-claim.ts

@@ -0,0 +1,76 @@
+// Whether a first sentence says something about its heading's subject, rather than announcing or restating it. Pure;
+// heading-echo reads it. The words that only announce or point (covers, below, 説明, 以下), the copulas and the
+// negations come from the language package's heading-announcer lexicon.
+import { isContent } from "./content-morphemes.ts";
+import type { LexiconEntry, Token } from "../plugin.ts";
+
+type Side = "before" | "after";
+
+export type AnnouncerWords = {
+  /** Words that announce the section or point at it: they carry no claim of their own. */
+  readonly announcing: ReadonlySet<string>;
+  /** Copulas (be, です), each with the side its complement stands on. */
+  readonly copulas: ReadonlyMap<string, Side>;
+  /** Words that deny what a copula links (There are no issues, is not in the manual): the denial is the claim. */
+  readonly negations: ReadonlySet<string>;
+};
+
+const patternsOf = (entries: readonly LexiconEntry[], group: string | undefined): Set<string> =>
+  new Set(entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase()));
+
+export const announcerWords = (entries: readonly LexiconEntry[]): AnnouncerWords => ({
+  announcing: patternsOf(entries, undefined),
+  copulas: new Map(entries.flatMap((entry): [string, Side][] => (entry.group === "copula" ? [[entry.pattern.toLowerCase(), entry.position ?? "after"]] : []))),
+  negations: patternsOf(entries, "negation"),
+});
+
+const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** Between a copula and its complement: not, very, the (is not the, are very). */
+const BRIDGING_POS = new Set(["ADV", "PART", "DET"]);
+
+/** What a copula at `at` links to, on its complement's side: the bridging words, then the complement when there is one. */
+const linkedBy = (tokens: readonly Token[], at: number, side: Side): Token[] => {
+  const outward = side === "after" ? tokens.slice(at + 1) : tokens.slice(0, at).reverse();
+  const complementAt = outward.findIndex((token) => !BRIDGING_POS.has(token.pos));
+  return complementAt === -1 ? outward : outward.slice(0, complementAt + 1);
+};
+
+/** An -ing form or a past participle names or modifies (Moving through the process, An object representing a server); it predicates only after a copula. */
+const NON_FINITE = new Set(["Ger", "Part"]);
+
+const isFiniteVerb = (token: Token): boolean => token.pos === "VERB" && !NON_FINITE.has(token.features?.["VerbForm"] ?? "");
+
+type Predicate = { readonly words: readonly Token[]; readonly negations: readonly Token[] };
+
+const copulaPredicate = (tokens: readonly Token[], at: number, side: Side, words: AnnouncerWords): Predicate => {
+  const linked = linkedBy(tokens, at, side);
+  return { words: linked.filter((word) => !BRIDGING_POS.has(word.pos)), negations: linked.filter((word) => words.negations.has(baseForm(word))) };
+};
+
+/** A finite verb that is no copula, a word turned into a verb by a light verb (変更し), or a copula's complement. */
+const predicatesOf = (tokens: readonly Token[], words: AnnouncerWords): Predicate[] =>
+  tokens.flatMap((token, index): Predicate[] => {
+    const side = words.copulas.get(baseForm(token));
+    if (side !== undefined) return [copulaPredicate(tokens, index, side, words)];
+    const lightVerbNext = tokens[index + 1]?.features?.["VerbType"] === "Light";
+    return isFiniteVerb(token) || lightVerbNext ? [{ words: [token], negations: [] }] : [];
+  });
+
+/**
+ * The sentence has a predicate of its own: a word that is not one of the heading's words and does not only announce or
+ * point (covers, below, 説明, 以下), or a denial the heading does not make. "All charges include sales tax." says
+ * something about charges; "This section covers installation." and "The full reference is in the manual." do not.
+ */
+/** A code name in a heading holds words of its own (restoreFixtures, cache_key, dry-run): the sentence that spells them out repeats them. */
+const CODE_NAME_PART = /\p{Lu}?[\p{Ll}\p{Nd}]+|\p{Lu}+(?!\p{Ll})/gu;
+
+const headingWords = (heading: readonly Token[]): Set<string> =>
+  new Set(heading.flatMap((token) => [baseForm(token), ...(token.surface.match(CODE_NAME_PART) ?? []).map((part) => part.toLowerCase())]));
+
+export const makesClaim = (heading: readonly Token[], sentence: readonly Token[], words: AnnouncerWords): boolean => {
+  const said = headingWords(heading);
+  const unsaid = (token: Token): boolean => !said.has(baseForm(token));
+  const ownWord = (token: Token): boolean => isContent(token) && unsaid(token) && !words.announcing.has(baseForm(token)) && !words.copulas.has(baseForm(token));
+  return predicatesOf(sentence, words).some((predicate) => predicate.negations.some(unsaid) || predicate.words.some(ownWord));
+};

package/src/detectors/heading-echo.ts

@@ -1,7 +1,9 @@
 import { lengthOf, proseText } from "../measure.ts";
 import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { titleTokens } from "../heading-label.ts";
+import { announcerWords, makesClaim } from "./heading-claim.ts";
 import { handsOver } from "./lead-in.ts";
 import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
@@ -65,6 +67,17 @@ const pointsElsewhere = (doc: ProseDocument, section: Section): boolean => {
   return first !== undefined && (holdsLink(doc.source, first.span, doc.links) || namesLocation(doc.source.slice(first.span.start, first.span.end)));
 };
 
+/**
+ * 最初の文が、見出しに無い述語で見出しの主題について何かを述べている（## Charges → All charges include sales tax.）。
+ * 予告や指示の語（covers, below, 説明, 以下）だけを述語にする文は、見出しを言い直しているだけで繰り返し。
+ */
+const statesClaim = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  return makesClaim(heading, first.tokens, announcerWords(doc.lexicons["heading-announcer"] ?? []));
+};
+
 /** A figure, with its thousands separators (1,320,000), compared without them. */
 const FIGURE = /\p{Nd}+(?:[,，]\p{Nd}{3})*/gu;
 /** Note marks are not figures: [^1], ※1, <sup>1</sup>. */
@@ -81,6 +94,17 @@ export const statesFigure = (heading: string, sentence: string): boolean => {
   return figuresOf(sentence).some((figure) => !inHeading.has(figure));
 };
 
+/**
+ * 最初の文が、見出しに無い名前や値を書いた、名前だけの行（レターヘッド）か項目と値の行（Customer: Laura Pennington）。
+ * 書式の頭で、見出しを言い直す文ではない。見出しをそのまま写した行（### 環境情報学研究科 → 環境情報学研究科、詳細：〈見出し〉）は繰り返し。
+ */
+const opensForm = (section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined || !isFormBlock(first.text, first.span.start, first.tokens)) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  return newContentMorphemes(heading, formValueTokens(first.text, first.span.start, first.tokens)) > 0;
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
 const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
@@ -88,9 +112,16 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
-    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section) && !statesFigure(section.heading, section.firstSentence?.text ?? ""))
+    .filter(
+      (section) =>
+        !leadsIn(doc, section, leadIns) &&
+        !pointsElsewhere(doc, section) &&
+        !statesFigure(section.heading, section.firstSentence?.text ?? "") &&
+        !opensForm(section),
+    )
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
+    .filter(({ section }) => !statesClaim(doc, section))
     .map(({ section, overlap }) => ({
       rule: "heading-echo",
       severity: "warning",

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/installment-total-mismatch.ts

@@ -4,12 +4,11 @@
 // and amount-range-word.
 import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
 import { installmentFeeMismatches, type InstallmentSeriesWords } from "../structure/installment-fee.ts";
-import { installmentTotalMismatches, type InstallmentAmount, type InstallmentWords, type PositionedWord } from "../structure/installment-total.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
+import { installmentTotalMismatches, type InstallmentWords, type PositionedWord } from "../structure/installment-total.ts";
 import type { StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
@@ -57,20 +56,6 @@ const seriesWordsOf = (doc: ProseDocument): InstallmentSeriesWords => ({
   feeLinks: patternsOf(doc, "installment-word", "fee-link"),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): InstallmentAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 const findingOf = (text: string, issue: StructureIssue, variant?: string): Finding => ({
   rule: "installment-total-mismatch",
   severity: "warning",
@@ -83,7 +68,7 @@ const findingOf = (text: string, issue: StructureIssue, variant?: string): Findi
 
 export const installmentTotalMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  const amounts = amountsOf(text, doc);
+  const amounts = statedAmountsOf(text, doc);
   const words = wordsOf(doc);
   const loans = installmentTotalMismatches(text, amounts, words);
   const headings = (doc.markup?.headings ?? []).map((heading) => heading.start);

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/list-parallel.ts

@@ -63,18 +63,56 @@ const isTitleCase = (text: string): boolean =>
     .split(/\s+/u)
     .every((word) => TITLE_SMALL_WORDS.has(word) || /^\p{Lu}/u.test(word));
 
-const englishHead = (sentences: readonly Sentence[]): string | undefined => {
-  const first = (sentences[0]?.tokens ?? []).find((token) => !SKIPPED_AT_END.has(token.pos));
-  if (first === undefined || isUnsure(first) || isTitleCase(sentences[0]?.text ?? "")) return undefined;
+/** A determiner that opens an object (the, a, your): no noun phrase goes on from its head with one. */
+const opensObject = (token: Token | undefined): boolean => token?.features?.["PronType"] === "Art" || token?.features?.["Poss"] === "Yes";
+
+const AFTER_ADJECTIVE = new Set(["ADP", "PART"]);
+
+/** A noun or adjective, or an ordinary word the tagger took for a name because it is capitalised (Toggle). */
+const isNounOrAdjective = (token: Token): boolean =>
+  token.pos === "NOUN" || token.pos === "ADJ" || (token.pos === "PROPN" && token.features?.["OrdinaryWord"] === "Yes");
+
+/**
+ * The head of an item whose first two words overrule the first word's tag, or undefined when they do not. "Open the console"
+ * and "Press the button" open with a verb. "Clean up after closing" and "Bake in the oven" may open with a verb or an
+ * adjective phrase (Close to the station), and "Washing machine space" with a compound noun or a gerund and its object
+ * (Washing dishes): neither is judged.
+ */
+const headFromNextWord = (first: Token, next: Token | undefined): "verb" | "unjudged" | undefined => {
+  if (isNounOrAdjective(first) && opensObject(next)) return "verb";
+  if (first.pos === "ADJ" && AFTER_ADJECTIVE.has(next?.pos ?? "")) return "unjudged";
+  return first.features?.["VerbForm"] === "Ger" && next?.pos === "NOUN" ? "unjudged" : undefined;
+};
+
+/** The head as the first word's tag gives it. */
+const headFromTag = (first: Token): string | undefined => {
+  if (isUnsure(first)) return undefined;
   // A participle (Generated files, Nested lists) modifies the noun after it; the item is a noun phrase, but the tag does not say so.
   if (first.pos === "VERB") return first.features?.["VerbForm"] === "Part" ? undefined : "verb";
   return NOUN_HEAD.has(first.pos) ? "noun" : undefined;
 };
 
-/** An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last). */
-export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string): string | undefined => {
+const englishHead = (sentences: readonly Sentence[], instructionVerbs: ReadonlySet<string>): string | undefined => {
+  const tokens = sentences[0]?.tokens ?? [];
+  const at = tokens.findIndex((token) => !SKIPPED_AT_END.has(token.pos));
+  const first = tokens[at];
+  if (at === -1 || first === undefined || isTitleCase(sentences[0]?.text ?? "")) return undefined;
+  // The word right after, punctuation included: in "Next, the candidate" the comma ends the opener.
+  const next = tokens[at + 1];
+  // Before a common noun the word may head a compound (Click fraud, Scroll bar), so its tag decides.
+  if (instructionVerbs.has(first.surface.toLowerCase()) && next?.pos !== "NOUN") return "verb";
+  const overruled = headFromNextWord(first, next);
+  if (overruled === undefined) return headFromTag(first);
+  return overruled === "verb" ? "verb" : undefined;
+};
+
+/**
+ * An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last).
+ * instructionVerbs: verbs the tagger does not know as verbs (click), from the adapter's instruction-verb word list.
+ */
+export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string, instructionVerbs: ReadonlySet<string> = new Set()): string | undefined => {
   if (language === "ja") return axis === "ending" ? japaneseEnding(sentences) : undefined;
-  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences);
+  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences, instructionVerbs);
 };
 
 const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
@@ -131,9 +169,10 @@ const listFindings = (doc: ProseDocument, list: BulletList, limit: number): Find
     const span = list.itemSpans[index];
     return span !== undefined && isJudged(doc.source.slice(span.start, sentences.at(-1)?.span.end ?? span.end), sentences);
   });
+  const instructionVerbs = new Set((doc.lexicons["instruction-verb"] ?? []).map((entry) => entry.pattern.toLowerCase()));
   return AXES.flatMap((axis) => {
     const items = judged.flatMap((sentences) => {
-      const form = formOf(axis, sentences, doc.language);
+      const form = formOf(axis, sentences, doc.language, instructionVerbs);
       return form === undefined ? [] : [{ sentences, form }];
     });
     const odd = minorityWithin(items, (item) => item.form === FORMS[axis][0], limit);

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()));
+};