chaffjs 0.33.0 → 0.35.0

package/src/detectors/acronym-definition.ts

@@ -0,0 +1,123 @@
+import { escapeRegExp } from "../orthography.ts";
+import { abbreviates } from "./acronym-expansion.ts";
+
+/**
+ * 括弧の展開の形をとらずに、文書が略語を定義している所。契約書の定義の一覧（**"BAA"** means …、"Protected Health Information" or
+ * "PHI" has the meaning …）、当事者の呼び名の並び（("Buyer" or "PNC")）、名前の後ろの言い換え（“temporary duty,” also known as “TDY”）、
+ * 名前だけの行（発行者の行の HM Revenue & Customs と、本文の HMRC）。どれも文書の source から一度だけ集める。
+ */
+
+/** 言語パッケージの語彙表から読む、定義を言う語（means、has the meaning）と、名前と略語の間に書く語（also known as、hereinafter）。 */
+export type DefinitionStatementWords = { readonly statements: readonly string[]; readonly markers: readonly string[] };
+
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : `(?:${words.map(escapeRegExp).join("|")})`);
+
+const ACRONYM = String.raw`[A-Z][A-Z&-]*[A-Z]`;
+const OPEN_QUOTE = `["“]`;
+const CLOSE_QUOTE = `["”]`;
+/** 引用符で囲んだ別の呼び名。 */
+const QUOTED = String.raw`${OPEN_QUOTE}[^"“”()（）\n]{1,80}${CLOSE_QUOTE}`;
+/**
+ * 空白・区切り・強調の印（定義の一覧は語を太字にする: **"BAA"**）と、3 文字までの小文字の語（or、and、the）。語そのものは見ない。
+ * 長さに上限を置くのは、文書全体を走査するときに空白の長い並びで後戻りが膨らまないため。
+ */
+const GAP = String.raw`[\s,;*_]{0,8}`;
+const SHORT_WORD = String.raw`\p{Ll}{1,3}(?!\p{L})`;
+const JOINER = String.raw`${GAP}(?:${SHORT_WORD}${GAP}){0,3}`;
+/** 呼び名どうしの間。読点か短い語が要る。並べただけの引用（"ABC" "Unrelated label"）は呼び名の並びではない。 */
+const LINK = String.raw`[\s*_]{0,8}(?:,|${SHORT_WORD})${GAP}(?:${SHORT_WORD}${GAP}){0,2}`;
+const QUOTED_MAX = 6;
+
+const captured = (text: string, pattern: RegExp): string[] => [...text.matchAll(pattern)].flatMap((match) => match.groups?.["acronym"] ?? []);
+
+/** 引用符で囲んだ略語と、その後ろの定義の語（"SOW" means、"PHI" has the meaning）。間に別の呼び名と 1 語（shall）を挟んでよい。 */
+const statementDefinitions = (source: string, statements: readonly string[]): string[] =>
+  statements.length === 0
+    ? []
+    : captured(
+        source,
+        new RegExp(
+          String.raw`${OPEN_QUOTE}(?<acronym>${ACRONYM})${CLOSE_QUOTE}(?:${LINK}${QUOTED}){0,${QUOTED_MAX}}${JOINER}(?:\p{Ll}{1,12}\s{1,3})?${oneOf(statements)}(?![\p{L}])`,
+          "gu",
+        ),
+      );
+
+/** 括弧の中が、引用符で囲んだ 2 つ以上の呼び名だけの並び（("Buyer" or "PNC")、(the "Company" and "ACME")）。1 つだけの (see "PNC") は呼び名の定義ではない。 */
+const LABEL_LIST = new RegExp(String.raw`[(（]${JOINER}${QUOTED}(?:${LINK}${QUOTED}){1,${QUOTED_MAX}}${GAP}[)）]`, "gu");
+const QUOTED_ACRONYM = new RegExp(String.raw`${OPEN_QUOTE}(?<acronym>${ACRONYM})${CLOSE_QUOTE}`, "gu");
+
+const labelDefinitions = (source: string): string[] => [...source.matchAll(LABEL_LIST)].flatMap((list) => captured(list[0], QUOTED_ACRONYM));
+
+/**
+ * 名前と、読点か引用符で区切った言い換えの語の後ろの、引用符で囲んだ略語（“temporary duty,” also known as “TDY”）。名前から略語の
+ * 文字が順に拾えるときだけ。区切りの無い所（the "TDY" office の the）は言い換えではない。
+ */
+const NAME_BEFORE = String.raw`(?<name>(?:[\p{L}'’-]+\s+){0,7}[\p{L}'’-]+)[,"”]+`;
+
+const markedDefinitions = (source: string, markers: readonly string[]): string[] =>
+  markers.length === 0
+    ? []
+    : [...source.matchAll(new RegExp(String.raw`${NAME_BEFORE}\s${oneOf(markers)}\s+${OPEN_QUOTE}(?<acronym>${ACRONYM})${CLOSE_QUOTE}`, "gu"))]
+        .filter((match) => abbreviates(match.groups?.["name"] ?? "", match.groups?.["acronym"] ?? ""))
+        .flatMap((match) => match.groups?.["acronym"] ?? []);
+
+/** 名前だけの行の語。強調の印を外した行が、大文字で始まる語と、その間の語・& だけ（HM Revenue & Customs）。見出しの行は名前の行ではない。 */
+const LINE_MARKS = /[*_]/gu;
+const HEADING = /^#{1,6}\s/u;
+const NAME_LINE_WORD = /^(?:\p{L}[\p{L}'’.-]*|&)$/u;
+const NAME_LINE_WORDS_MAX = 8;
+const CAPITALS_WORD = /^\p{Lu}+$/u;
+const CAPITALISED = /^\p{Lu}/u;
+/** 文の終わりの記号で終わる行（Tell HMRC first.）は文で、名前の行ではない。 */
+const SENTENCE_END = /[.!?:;]$/u;
+
+const nameLineWords = (line: string): string[] => {
+  const text = line.replaceAll(LINE_MARKS, " ").trim();
+  if (HEADING.test(line) || SENTENCE_END.test(text)) return [];
+  const words = text.split(/\s+/u);
+  const isName =
+    words.length >= 2 && words.length <= NAME_LINE_WORDS_MAX && CAPITALISED.test(words[0] ?? "") && words.every((word) => NAME_LINE_WORD.test(word));
+  return isName ? words : [];
+};
+
+/** 名前の頭文字。大文字だけの語（HM）は全部の文字を、大文字で始まる語は頭の 1 文字を使い、小文字の語と & は飛ばす。 */
+const initialsOf = (words: readonly string[]): string =>
+  words
+    .filter((word) => CAPITALISED.test(word))
+    .map((word) => (CAPITALS_WORD.test(word) ? word : word.charAt(0)))
+    .join("");
+
+/**
+ * 名前の行と読むのは、コロンで終わる短い項目名の行（From:、Published by:）のすぐ後ろの、発行者や当事者の名前の行だけ。
+ * 大文字で始まり小文字が続く語が 2 つ以上あり、頭文字が 3 文字以上のもの。見出しや本文の行（## Area Forecast Discussion、
+ * Advance Purchase）は、名前と略語を結ぶ書き手の印が無いので展開と読まない。
+ */
+const FIELD_LABEL = /^\p{Lu}[\p{L} ]{0,30}:$/u;
+const NAME_LINE_INITIALS_MIN = 3;
+const TITLE_WORDS_MIN = 2;
+
+const initialsOfNameLine = (line: string): string => {
+  const words = nameLineWords(line);
+  const titleWords = words.filter((word) => CAPITALISED.test(word) && !CAPITALS_WORD.test(word)).length;
+  const initials = initialsOf(words);
+  return titleWords >= TITLE_WORDS_MIN && initials.length >= NAME_LINE_INITIALS_MIN ? initials : "";
+};
+
+const nameLineDefinitions = (source: string): string[] => {
+  const lines = source
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => line !== "");
+  return lines
+    .flatMap((line, index) => (index > 0 && FIELD_LABEL.test(lines[index - 1] ?? "") ? [initialsOfNameLine(line)] : []))
+    .filter((initials) => initials !== "");
+};
+
+/** 文書が括弧の展開の形をとらずに定義した略語。 */
+export const statedAcronyms = (source: string, words: DefinitionStatementWords): ReadonlySet<string> =>
+  new Set([
+    ...statementDefinitions(source, words.statements),
+    ...labelDefinitions(source),
+    ...markedDefinitions(source, words.markers),
+    ...nameLineDefinitions(source),
+  ]);

package/src/detectors/acronym-lone.ts

@@ -0,0 +1,26 @@
+// 説明のない略語が上限に届かない文書で、それでも 1 つを指してよいかを決める手がかり。
+
+/** 大文字で始まり小文字が続く語（International、Treasury）。名前を作る語の形。 */
+const TITLE_WORD_AFTER = /^[\s–-]+\p{Lu}\p{Ll}/u;
+const TITLE_WORD_BEFORE = /\p{Lu}\p{Ll}+[\s–-]+$/u;
+/** 文の頭の語は、名前でなくても大文字で始まる（The CFR）。 */
+const FIRST_WORD = /^\P{L}*\p{L}+[\s–-]+$/u;
+
+/**
+ * 略語が、大文字で始まる語と並んで 1 つの名前を作っているか（SRI International、HM Treasury、Math FMA）。
+ * 名前の一部の略語は、読み手が名前として受け取るもので、展開を待つ略語とは言い切れない。start と end は文の中の略語の位置。
+ */
+export const isNamePart = (sentence: string, start: number, end: number): boolean => {
+  const before = sentence.slice(0, start);
+  return TITLE_WORD_AFTER.test(sentence.slice(end)) || (TITLE_WORD_BEFORE.test(before) && !FIRST_WORD.test(before));
+};
+
+/**
+ * 略語だけを括弧に入れた所があるか（National Vulnerability Database (NVD)）。書き手が名前を書いて略語を添えた、いちばん確かな展開の形。
+ * 略語の後ろの括弧（README ([#1455](…))）はリンクや注記にも使うので、書き手が展開する人かを測るときは数えない。
+ */
+export const isBracketed = (text: string, acronym: string): boolean => new RegExp(String.raw`[(（]\s?["“「]?${acronym}["”」]?\s?[)）]`, "u").test(text);
+
+/** 見出しに出る略語は、その文書が扱う相手の名前（NASA Selects …）。読み手はそれを知って読みに来る。 */
+export const isInHeading = (headings: readonly string[], acronym: string): boolean =>
+  headings.some((heading) => new RegExp(String.raw`(?<![A-Za-z0-9_&])${acronym}(?![A-Za-z0-9_&])`, "u").test(heading));

package/src/detectors/acronym-name.ts

@@ -0,0 +1,117 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 大文字で書いた名前の部品と決まり文句で、展開を待つ略語ではないもの（JVLS, LLC、TRATON SE、AU$10、45 CFR §164、
+ * Federal Express, UPS, DHL、HM Revenue & Customs、512 Bayshore DR、NOW, THEREFORE、AND/OR）。どれも語彙表の語が決まった形の中に
+ * あるときだけ認める。語は言語パッケージの語彙表から読み、ここには形の組み立てだけを置く。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+/** 言語パッケージの語彙表から読む、名前の部品の語と決まり文句。字面どおりに照らす。 */
+export type NameWords = {
+  /** 会社名の後ろに大文字で書く法人の形（LLC、INC、SE、PTE、PTY）。 */
+  readonly legalForms: readonly string[];
+  /** 名詞の前に置く限定の語（the、this、each）。文の頭で大文字になっても（The SE team）名前の語ではない。大小を問わずに照らす。 */
+  readonly determiners: readonly string[];
+  /** 法令・官報の引用の大文字の部分（45 CFR §164、21 USC §301、94/820/EC）。 */
+  readonly citationSeries: readonly string[];
+  /** 運送会社の名前（UPS、DHL、Federal Express）。2 社以上を並べたときだけ名前と読む。 */
+  readonly carriers: readonly string[];
+  /** 大文字で始まる語の前に置いて名前を作る語（HM Revenue & Customs、HMS Victory）。 */
+  readonly namePrefixes: readonly string[];
+  /** 番地と通りの名前の後ろに書く、通りの種類の略し（512 Bayshore DR）。 */
+  readonly streetSuffixes: readonly string[];
+  /** 大文字で書く決まり文句（NOW, THEREFORE、AND/OR）。句のままでだけ外す。OR だけなら Oregon でもある。 */
+  readonly capitalPhrases: readonly string[];
+};
+
+const EDGE_BEFORE = String.raw`(?<![\p{L}\p{N}_&])`;
+const EDGE_AFTER = String.raw`(?![\p{L}\p{N}_&])`;
+
+/**
+ * 語彙表の語のどれか。空の語彙表は「その書き方が無い」。空の選択肢 (?:) は至る所で空文字に当たるので、何にも当たらない形にする。
+ * 長い語から試す。短い語が先だと、それを頭に持つ長い語（PTE と PTE. のような書き分け）が丸ごと当たらない。
+ */
+export const oneOf = (words: readonly string[]): string =>
+  words.length === 0
+    ? "(?!)"
+    : `(?:${words
+        .toSorted((left, right) => right.length - left.length)
+        .map(escapeRegExp)
+        .join("|")})`;
+
+const spansOf = (text: string, pattern: RegExp): Span[] =>
+  [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** 名前の語。大文字で始まり、点・& ・アポストロフィ・ハイフンを含んでよい（BorrowMoney.com、PTE.、O'Neil）。 */
+const NAME_WORD = String.raw`\p{Lu}[\p{L}\p{N}&.'’-]*`;
+/** 法人の形の前に並ぶ名前の語の数の上限（CNH INDUSTRIAL SOUTH DAKOTA, INC.）。文の頭まで遡って別の語を名前に入れないため。 */
+const NAME_WORDS_MAX = 5;
+
+/**
+ * 名前の語のすぐ後ろ（読点を挟んでもよい）の法人の形と、その前の名前（JVLS, LLC、CPM Medical Consultants LLC、TRATON SE、
+ * GitLab Singapore PTE. LTD.）。名前の語は空白だけで続くものを数え、読点で切れた先（CENTENE CORPORATION, MAYFLOWER …）は入れない。
+ * 名前に続けて書いた括弧のすぐ後ろの形（SUNCALL（Guangzhou）CO.,LTD.）も名前の終わり。空白を挟んだ括弧（Section (A) LLC）は名前の一部ではない。形のすぐ前が限定の語なら名前ではない（The SE team）。
+ */
+export const companyNameSpans = (text: string, forms: readonly string[], determiners: readonly string[]): Span[] => {
+  if (forms.length === 0) return [];
+  const single = `${oneOf(forms)}${EDGE_AFTER}`;
+  // 形を重ねて書く（PTE. LTD.、CO.,LTD.）。
+  const form = String.raw`${single}(?:\.?,?[ \t]*${single})*`;
+  const named = new RegExp(String.raw`${EDGE_BEFORE}(?:${NAME_WORD}[ \t]+){0,${NAME_WORDS_MAX - 1}}(?<last>${NAME_WORD})(?:,[ \t]*|[ \t]+)${form}`, "gu");
+  const bracketed = new RegExp(String.raw`(?<=${NAME_WORD}[(（][\p{L} ]+[)）][ \t]*)${form}`, "gu");
+  const determiner = new Set(determiners.map((word) => word.toLowerCase()));
+  const names = [...text.matchAll(named)].filter((match) => !determiner.has((match.groups?.["last"] ?? "").toLowerCase()));
+  return [...names.map((match) => ({ start: match.index, end: match.index + match[0].length })), ...spansOf(text, bracketed)];
+};
+
+/** 通貨の記号に付けた大文字（USD$、AU$10、US$ 5）。国や通貨の印で、略語ではない。 */
+const CURRENCY_PREFIX = new RegExp(String.raw`${EDGE_BEFORE}\p{Lu}{1,3}(?=[$€£¥])`, "gu");
+
+export const currencySymbolSpans = (text: string): Span[] => spansOf(text, CURRENCY_PREFIX);
+
+/**
+ * 引用の形の中の、法令の名前（45 CFR Parts 160、CFR §164.524、21 USC §301、22 CCR §§ 12701、94/820/EC）。後ろに条（§、Part、
+ * 番号）があるか、/ で繋いだ番号の後ろのときだけ。法令集そのものを言う所（the CFR title、the 2 CFR export）は略語のまま数える。
+ */
+export const citationSpans = (text: string, series: readonly string[]): Span[] => {
+  if (series.length === 0) return [];
+  const name = oneOf(series);
+  return spansOf(text, new RegExp(String.raw`(?<=\d/)${name}${EDGE_AFTER}|${EDGE_BEFORE}${name}(?=[ \t]*(?:§|[Pp]arts?[ \t]+\d|\d))`, "gu"));
+};
+
+/** 運送会社の名前。同じ文に 2 社以上を並べた所（Federal Express, UPS, DHL）だけ、どれも名前と読む。1 社だけの UPS は電源装置でもある。 */
+export const carrierListSpans = (text: string, carriers: readonly string[]): Span[] => {
+  if (carriers.length === 0) return [];
+  const pattern = new RegExp(`${EDGE_BEFORE}${oneOf(carriers)}${EDGE_AFTER}`, "gu");
+  const spans = spansOf(text, pattern);
+  return new Set(spans.map((span) => text.slice(span.start, span.end))).size < 2 ? [] : spans;
+};
+
+/** 大文字で始まる語の前に置いた、名前を作る語（HM Revenue & Customs、HM Treasury）。 */
+export const namePrefixSpans = (text: string, prefixes: readonly string[]): Span[] =>
+  prefixes.length === 0 ? [] : spansOf(text, new RegExp(String.raw`${EDGE_BEFORE}${oneOf(prefixes)}(?=[ \t]+\p{Lu}\p{Ll})`, "gu"));
+
+/** 番地と、大文字で始まり小文字が続く通りの名前の後ろの、通りの種類（512 Bayshore DR、4060 Johns Creek PKWY）。3 AI CT は住所ではない。 */
+export const streetSuffixSpans = (text: string, suffixes: readonly string[]): Span[] =>
+  suffixes.length === 0
+    ? []
+    : spansOf(text, new RegExp(String.raw`(?<=${EDGE_BEFORE}\d+[A-Z]?[ \t]+(?:\p{Lu}\p{Ll}[\p{L}'’.-]*[ \t]+){1,3})${oneOf(suffixes)}${EDGE_AFTER}`, "gu"));
+
+/** 大文字で書く決まり文句（NOW, THEREFORE、AND/OR）。 */
+export const capitalPhraseSpans = (text: string, phrases: readonly string[]): Span[] =>
+  phrases.length === 0 ? [] : spansOf(text, new RegExp(`${EDGE_BEFORE}${oneOf(phrases)}${EDGE_AFTER}`, "gu"));
+
+/** 文の中で、名前の部品と決まり文句として略語から外す大文字を含む範囲。語彙表から一度だけ組み立てて、文ごとに呼ぶ。 */
+export const nameSpansOf =
+  (words: NameWords) =>
+  (text: string): Span[] => [
+    ...companyNameSpans(text, words.legalForms, words.determiners),
+    ...currencySymbolSpans(text),
+    ...citationSpans(text, words.citationSeries),
+    ...carrierListSpans(text, words.carriers),
+    ...namePrefixSpans(text, words.namePrefixes),
+    ...streetSuffixSpans(text, words.streetSuffixes),
+    ...capitalPhraseSpans(text, words.capitalPhrases),
+  ];

package/src/detectors/age-words.ts

@@ -0,0 +1,12 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { AgeWord, AgeWords } from "../facts/age-values.ts";
+
+const ageWordsAt = (doc: ProseDocument, id: string): AgeWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): AgeWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+/** 年齢の語: 印（fact-age-mark）、上限の印（fact-age-limit）、範囲をつなぐ語（fact-age-joiner）。 */
+export const ageWordsOf = (doc: ProseDocument): AgeWords => ({
+  marks: ageWordsAt(doc, "fact-age-mark"),
+  limits: ageWordsAt(doc, "fact-age-limit"),
+  joiners: (doc.lexicons["fact-age-joiner"] ?? []).map((entry) => entry.pattern),
+});

package/src/detectors/annual-pay-mismatch.ts

@@ -3,9 +3,8 @@
 // are annual-pay-label, the other words annual-pay-word, approximate-marker, duration-month, number-word (digit),
 // range-connector and amount-range-word.
 import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
-import { annualPayMismatches, type AnnualPayWords, type PayAmount, type PositionedWord } from "../structure/annual-pay.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
+import { annualPayMismatches, type AnnualPayWords, type PositionedWord } from "../structure/annual-pay.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
 
@@ -44,23 +43,9 @@ const wordsOf = (doc: ProseDocument): AnnualPayWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): PayAmount[] => {
-  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 }];
-  });
-};
-
 export const annualPayMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return annualPayMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return annualPayMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "annual-pay-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/blank-structure.ts

@@ -7,7 +7,7 @@ import { eachPreOrder, foldPostOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { amountColumnOf, isTotalRowGap, type BodyRow } from "../structure/total-row-blank.ts";
 import { isAmountNameLine, isTotalLine } from "../structure/total-line.ts";
-import { isTotalLabel } from "../structure/total.ts";
+import { isTotalLabel, withoutLeadingBlankCells } from "../structure/total.ts";
 
 /** Fewer body rows than this, and one blank is as likely a choice as a gap. */
 const MIN_BODY_ROWS = 3;
@@ -178,7 +178,8 @@ const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexic
 
 /**
  * A total row starts with a total word (total-label, with total-label-qualifier or total-period-qualifier: Week total),
- * a tax word (tax-label), or is named by a computed amount (net-amount-label: Gross pay, Net pay).
+ * a tax word (tax-label), or is named by a computed amount (net-amount-label: Gross pay, Net pay). The word may sit in the
+ * first cell that is not blank (| | Total | $1,200 |): the cells before it are left blank on purpose.
  */
 const totalRowOf = (doc: ProseDocument): IsTotalRow => {
   const totals = {
@@ -188,7 +189,7 @@ const totalRowOf = (doc: ProseDocument): IsTotalRow => {
     amountNames: patternsOf(doc, "net-amount-label"),
   };
   const taxes = patternsOf(doc, "tax-label");
-  return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(rowText, taxes);
+  return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(withoutLeadingBlankCells(rowText), taxes);
 };
 
 export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) => tableBlanks(doc.source, doc.replyQuotes ?? [], totalRowOf(doc)));

package/src/detectors/capitalised-term.ts

@@ -16,6 +16,18 @@ export type CapitalisedWords = {
   readonly divisions: readonly string[];
   /** Small words inside one name (Statement of Work, Trials and Betas). */
   readonly joiners: readonly string[];
+  /** Words that end a longer name the run only starts (Federal Food, Drug, and Cosmetic Act). */
+  readonly nameEnds: readonly string[];
+  /** Company forms and places, which end a name right after a comma too (Post Holdings, Inc.; Canton, Ohio). */
+  readonly formEnds: readonly string[];
+  /** Words before the quoted label in brackets that define the run ((the "FDA")). */
+  readonly definitionMarkers: readonly string[];
+  /** Words opening brackets that say where the run is defined ((as defined in the Merger Agreement)). */
+  readonly definedElsewhere: readonly string[];
+  /** Words before a party's capacity after its name (Citibank, N.A., as Administrative Agent). */
+  readonly capacityMarkers: readonly string[];
+  /** Articles, which may stand between a capacity word and the capacity (as the Borrower). */
+  readonly articles: readonly string[];
 };
 
 /** A term the document defines; bare is a definition with no defining word (("GPC")), which names more than it defines. */
@@ -100,15 +112,144 @@ const writtenInLowerCase = (text: string, term: string): boolean => {
   return new RegExp(String.raw`(?<!\p{L})${words}(?:e?s)?(?!\p{L})`, "u").test(text);
 };
 
+/** How many tokens past a run a longer name may still end (’s Investors Service, Inc: five). */
+const NAME_REACH = 8;
+/** Marks inside one name: Post Holdings, Inc; Davis Polk & Wardwell LLP; Moody’s Investors Service. */
+const NAME_GLUE = new Set([",", "&", ".", "'s", "’s"]);
+const DIGIT_START = /^\d/u;
+
+/** The last word of each name-ending entry (Kingdom of United Kingdom), without a closing full stop. */
+const lastWordsOf = (entries: readonly string[]): Set<string> =>
+  new Set(
+    entries
+      .flatMap((entry) =>
+        entry
+          .split(/[\s,]+/u)
+          .filter((word) => word !== "")
+          .slice(-1),
+      )
+      .map((word) => word.replace(/\.$/u, "")),
+  );
+
+/** Commas in a serial name's list (Federal Food, Drug, and Cosmetic Act). */
+const SERIAL_COMMAS = 2;
+
+type NameEnds = { readonly names: ReadonlySet<string>; readonly forms: ReadonlySet<string>; readonly formEntries: ReadonlySet<string> };
+
+/**
+ * Across a comma, a company form or a place ends the run's name only as the whole of what follows the comma (Post
+ * Holdings, Inc; London, United Kingdom), and a name word only at the end of a serial list of two commas, the last
+ * followed by a joiner (Federal Food, Drug, and Cosmetic Act): Confidential Information, Receiving Party and Servicer,
+ * Navistar Securities Corporation are two things each.
+ */
+const endsName = (glued: readonly Token[], at: number, ends: NameEnds, joiners: ReadonlySet<string>): boolean => {
+  const surface = glued[at]?.surface ?? "";
+  const before = glued.slice(0, at);
+  const surfaces = before.map((token) => token.surface);
+  const comma = surfaces.lastIndexOf(",");
+  if (comma === -1) return ends.forms.has(surface) || ends.names.has(surface);
+  const afterComma = glued.slice(comma + 1, at + 1);
+  if (ends.formEntries.has(afterComma.map((token) => token.surface).join(" "))) return true;
+  const commas = surfaces.filter((each) => each === ",").length;
+  return ends.names.has(surface) && commas >= SERIAL_COMMAS && joiners.has(afterComma[0]?.surface ?? "");
+};
+
+/** The run only starts a longer name: the words after it, joined by commas, ampersands and joiners, reach a word that ends a name. */
+const startsLongerName = (tokens: readonly Token[], end: number, ends: NameEnds, joiners: ReadonlySet<string>): boolean => {
+  const reach = tokens.slice(end, end + NAME_REACH);
+  const stop = reach.findIndex((token, at) => {
+    const before = tokens[end + at - 1];
+    return before === undefined || !adjacent(before, token) || !(NAME_GLUE.has(token.surface) || joiners.has(token.surface) || continues(token));
+  });
+  const glued = reach.slice(0, stop === -1 ? reach.length : stop);
+  return glued.some((_, at) => endsName(glued, at, ends, joiners));
+};
+
+/** A number right after the run makes it a numbered name (Proposition 65, Vaccines 2Go) or a contents line's page. */
+const numberedName = (last: Token, after: Token | undefined): boolean => after !== undefined && adjacent(last, after) && DIGIT_START.test(after.surface);
+
+/** The words as written and with their first letter capitalised (the, The), as one alternation. */
+const alternativesOf = (words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "")
+    .flatMap((word) => [word, word.charAt(0).toUpperCase() + word.slice(1)])
+    .map(escapeRegExp)
+    .join("|");
+
+/** A quoted label: a capitalised word or more in quotes, closing the brackets or followed by another label ("Buyer" or "PNC"). */
+const QUOTED_LABEL = String.raw`["“]\p{Lu}[^"“”\n]{0,60}["”][ \t]*(?:\)|,|;|or[ \t]|and[ \t])`;
+
+/**
+ * Brackets right after a run that define it, so the run is what a definition names, not a term in use: a quoted label
+ * (Food and Drug Administration (the "FDA"), Certificate of Analysis ("COA")) or a pointer to where it is defined
+ * (Closing (as defined in the Merger Agreement)). A quoted phrase in lower case (("including records")) is no label.
+ */
+const definitionAfterPattern = (words: CapitalisedWords): RegExp => {
+  const markers = alternativesOf(words.definitionMarkers);
+  const elsewhere = alternativesOf(words.definedElsewhere);
+  const label = markers === "" ? QUOTED_LABEL : String.raw`(?:(?:${markers})[ \t]+)*${QUOTED_LABEL}`;
+  const opening = elsewhere === "" ? label : String.raw`(?:${label}|(?:${elsewhere})(?!\p{L}))`;
+  return new RegExp(String.raw`^[ \t]*\([ \t]*${opening}`, "u");
+};
+
+/** How much text after a run the bracket check reads. */
+const DEFINITION_AFTER_CHARS = 120;
+
+/** The initials of a run's words, with and without its joiners (PFHOF and PFHF for Pro Football Hall of Fame). */
+const initialsOf = (term: string, joiners: ReadonlySet<string>): string[] => {
+  const words = term.split(/[\s-]+/u).filter((word) => word !== "");
+  const initials = (kept: readonly string[]): string => kept.map((word) => word.charAt(0).toUpperCase()).join("");
+  return words.length < 2 ? [] : [initials(words), initials(words.filter((word) => !joiners.has(word)))];
+};
+
+/**
+ * The run names the capacity a named party acts in, in a list of parties to some agreement (Citibank, N.A., as
+ * Administrative Agent; the Company, as the Borrower): the name, a comma, a capacity word and perhaps an article.
+ */
+const capacityOfAName = (tokens: readonly Token[], start: number, words: CapitalisedWords): boolean => {
+  const before = tokens[start - 1];
+  const at = before !== undefined && words.articles.includes(before.surface) ? start - 2 : start - 1;
+  const marker = tokens[at];
+  const comma = tokens[at - 1];
+  const name = tokens[at - 2];
+  if (marker === undefined || comma?.surface !== "," || name === undefined) return false;
+  return words.capacityMarkers.includes(marker.surface) && (continues(name) || name.surface === ".");
+};
+
+/**
+ * Whether a run is a name by what surrounds it: a number after it, a longer name it starts, brackets after it that
+ * define it, initials that spell a term the document defines (“IRS” means the Internal Revenue Service), or a capacity.
+ */
+type NameCue = (tokens: readonly Token[], start: number, end: number, term: string) => boolean;
+
+const nameCues = (input: CapitalisedInput, joiners: ReadonlySet<string>): NameCue => {
+  const words = input.words;
+  const ends = { names: lastWordsOf(words.nameEnds), forms: lastWordsOf(words.formEnds), formEntries: new Set(words.formEnds) };
+  const definitionAfter = definitionAfterPattern(words);
+  const abbreviations = new Set([...input.defined.map((definition) => definition.term), ...input.named].filter((term) => ACRONYM.test(term)));
+  return (tokens, start, end, term) => {
+    const last = tokens[end - 1];
+    if (last === undefined) return false;
+    return (
+      numberedName(last, tokens[end]) ||
+      startsLongerName(tokens, end, ends, joiners) ||
+      definitionAfter.test(input.source.slice(last.span.end, last.span.end + DEFINITION_AFTER_CHARS)) ||
+      initialsOf(term, joiners).some((initials) => abbreviations.has(initials)) ||
+      capacityOfAName(tokens, start, words)
+    );
+  };
+};
+
 /**
  * The first use of each capitalised run used inside a sentence like a defined term that names nothing the language
  * package lists, is not set apart by markup, is never written in lower case, and neither is nor holds a defined or named
- * term in any case.
+ * term in any case. A run that starts a longer name, carries a number, or is defined by the brackets after it is a name.
  */
 export const capitalisedTerms = (input: CapitalisedInput): CapitalisedTerm[] => {
   const defining = input.defined.filter((definition) => definition.bare !== true && DEFINED_FORM.test(definition.term));
   if (defining.length < MIN_DEFINED) return [];
   const joiners = new Set(input.words.joiners);
+  const isName = nameCues(input, joiners);
   const divisions = new Set(input.words.divisions.flatMap(formsOf));
   const known = new Set([...input.defined.map((definition) => definition.term), ...input.named, ...input.words.names].flatMap(formsOf));
   const isKnown = (term: string): boolean => partsOf(term).some((part) => formsOf(part).some((form) => known.has(form)));
@@ -119,7 +260,8 @@ export const capitalisedTerms = (input: CapitalisedInput): CapitalisedTerm[] =>
       if (first === undefined || last === undefined || !placedLikeATerm(tokens[start - 1], tokens[end])) return [];
       if (inside(first.span.start, input.marked) || formsOf(first.surface).some((form) => divisions.has(form))) return [];
       const term = input.source.slice(first.span.start, last.span.end);
-      return isKnown(term) || writtenInLowerCase(input.readable, term) ? [] : [{ offset: first.span.start, term }];
+      if (isKnown(term) || isName(tokens, start, end, term)) return [];
+      return writtenInLowerCase(input.readable, term) ? [] : [{ offset: first.span.start, term }];
     }),
   );
   return uses.filter((use, index) => uses.findIndex((other) => formsOf(other.term).some((form) => formsOf(use.term).includes(form))) === index);
@@ -130,12 +272,20 @@ const QUOTED = /["“]([^"“”\n]{1,80}?)[,.]?["”]/gu;
 const HTML_ELEMENT = /<([a-z][a-z0-9]*)\b[^>]*>[^<]*<\/\1>/giu;
 const TABLE_ROW = /^[ \t]*\|.*$/gmu;
 const ITEM_LABEL = /^[ \t]*(?:[*+-]|\d+[.)])[ \t]+[^:\n]{1,80}:/gmu;
+const CAPTION_WORD = String.raw`\p{Lu}[\p{L}'’-]*`;
+const CAPTION_SMALL = String.raw`(?:of|and|or|to|the|for|with|in|on|a|an|by|from|under|upon|as|at|not)[ \t]+`;
+/** A clause's run-in caption: its number, then capitalised words up to a full stop or colon (5.8 No Representation or Warranty.). */
+const CAPTION = new RegExp(
+  String.raw`(?:^|(?<=[.;:][ \t]+))[ \t]*(?:(?:Section|Article|SECTION|ARTICLE)[ \t]+)?(?:\d+(?:\.\d+)*\.?|\([a-z\d]{1,4}\))[ \t]+` +
+    String.raw`${CAPTION_WORD}(?:(?:[ \t]+|[;,][ \t]*)(?:${CAPTION_SMALL})*${CAPTION_WORD}){0,10}(?=[.:](?:\s|$))`,
+  "gmu",
+);
 
 const spansOf = (source: string, pattern: RegExp): Span[] =>
   [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
 
-/** Bold, HTML elements, table rows and list items' labels in a Markdown source: labels and cells, not running text. */
-export const setApartSpans = (source: string): Span[] => [BOLD, HTML_ELEMENT, TABLE_ROW, ITEM_LABEL].flatMap((pattern) => spansOf(source, pattern));
+/** Bold, HTML elements, table rows, list items' labels and clauses' run-in captions: labels and cells, not running text. */
+export const setApartSpans = (source: string): Span[] => [BOLD, HTML_ELEMENT, TABLE_ROW, ITEM_LABEL, CAPTION].flatMap((pattern) => spansOf(source, pattern));
 
 const LINK_DESTINATION = /\]\([^)\n]*\)|<?https?:\/\/[^\s)>]+>?/gu;
 

package/src/detectors/caps-caption.ts

@@ -0,0 +1,61 @@
+/**
+ * Captions set in capitals: a capital run that opens a paragraph and ends in a colon ("AGENCY:", "DIRECT HIRE AUTHORITY:
+ * This position is …"), or that is a paragraph of its own ("WORKING GROUP MEMBERS"). Notices, forms and reports set their
+ * captions this way by convention, and prose that names one ("the FOR FURTHER INFORMATION CONTACT section") repeats it.
+ * A line of a hard-wrapped paragraph in capitals (a disclaimer) has text above it, so it is no caption.
+ */
+
+/** Markdown heading or list marks and spaces that may stand before a caption on its line. */
+const LINE_LEAD = /^[ \t]*(?:#{1,6}[ \t]+|[-*+][ \t]+)?$/u;
+const BLANK_LINE = /^[ \t\r]*$/u;
+const LINE_END = /^[ \t\r]*(?:\n|$)/u;
+const LEAD = /^[ \t]*(?:#{1,6}[ \t]+|[-*+][ \t]+)?/u;
+const CAPITAL_RUN = /^[A-Z][A-Z']*(?:,? [A-Z][A-Z']*)*/u;
+
+/** The line before the one that starts at lineStart, or undefined at the start of the source. */
+const lineBefore = (source: string, lineStart: number): string | undefined =>
+  lineStart === 0 ? undefined : source.slice(source.lastIndexOf("\n", lineStart - 2) + 1, lineStart - 1);
+
+const opensParagraph = (source: string, lineStart: number): boolean => {
+  const above = lineBefore(source, lineStart);
+  return above === undefined || BLANK_LINE.test(above);
+};
+
+/** Whether the text after a run ends the caption: a colon, or the end of a paragraph. */
+const endsCaption = (rest: string): boolean => {
+  if (rest.startsWith(":")) return true;
+  if (!LINE_END.test(rest)) return false;
+  const next = rest.slice(rest.indexOf("\n") + 1).split("\n", 1)[0] ?? "";
+  return !rest.includes("\n") || BLANK_LINE.test(next);
+};
+
+/** Whether the capital run at [start, end) of the source is a caption: it opens its paragraph and ends in a colon or the paragraph's end. */
+export const isCaptionAt = (source: string, start: number, end: number): boolean => {
+  const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+  return LINE_LEAD.test(source.slice(lineStart, start)) && opensParagraph(source, lineStart) && endsCaption(source.slice(end));
+};
+
+/** The capital run that opens a line, after its heading or list mark, with where it starts in the source. */
+const runOpening = (line: string, lineStart: number): { readonly words: string; readonly start: number } | undefined => {
+  const lead = LEAD.exec(line)?.[0].length ?? 0;
+  const words = CAPITAL_RUN.exec(line.slice(lead))?.[0];
+  return words === undefined ? undefined : { words, start: lineStart + lead };
+};
+
+/** The captions a source sets in capitals, each as its words ("FOR FURTHER INFORMATION CONTACT"). */
+export const captionsOf = (source: string): ReadonlySet<string> => {
+  const lines = source.split("\n");
+  const starts = lines.reduce<number[]>(
+    (acc, line) => {
+      acc.push((acc.at(-1) ?? 0) + line.length + 1);
+      return acc;
+    },
+    [0],
+  );
+  return new Set(
+    lines.flatMap((line, at) => {
+      const run = runOpening(line, starts[at] ?? 0);
+      return run !== undefined && isCaptionAt(source, run.start, run.start + run.words.length) ? [run.words] : [];
+    }),
+  );
+};