chaffjs 0.16.0 → 0.18.0

package/src/custom/regex-safety.ts

@@ -0,0 +1,118 @@
+// Whether a team's regular expression can run away. JavaScript's engine backtracks, so a pattern such as (a+)+ takes time
+// exponential in the length of a line that almost matches. Pure: the pattern is read as text, never run on a document.
+
+/** Longer patterns are refused: a rule that needs one is better written as several. */
+export const MAX_PATTERN_LENGTH = 500;
+
+/**
+ * More repeats of varying count (*, +, {1,9}) than this are refused. Repeats side by side (a*a*a*b, a{0,99}a{0,99}…) do
+ * not nest, but their work multiplies: a line that almost matches costs its length to the power of their number.
+ */
+export const MAX_REPEATS = 3;
+
+export type RegexRefusal = "too-long" | "nested-quantifier" | "too-many-repeats" | "backreference" | "empty-match" | "invalid";
+
+/** An open group: where its body starts, and whether it holds a repeat of varying count (a+, a?, a{1,3}) or an alternation. */
+type Group = { readonly start: number; varies: boolean; alternation: boolean };
+
+/** A quantifier: its length, whether it has no upper bound, whether its count varies, and whether it can repeat more than once. */
+type Quantifier = { readonly length: number; readonly unbounded: boolean; readonly varies: boolean; readonly many: boolean };
+
+type Scan = { at: number; repeats: number; readonly stack: Group[] };
+
+const QUANTIFIER_START: ReadonlySet<string> = new Set(["*", "+", "?", "{"]);
+const BRACE = /^\{(\d+)(,(\d*))?\}\??/u;
+const BACKREFERENCE = /^\\(?:[1-9]|k<)/u;
+const CLASS_BODY = /^\^?\]?(?:\\.|[^\]\\])*\]/u;
+
+/** The quantifier at pattern[at], or undefined when none is there. */
+const quantifierAt = (pattern: string, at: number): Quantifier | undefined => {
+  const char = pattern[at];
+  if (char === undefined || !QUANTIFIER_START.has(char)) return undefined;
+  if (char !== "{") return { length: pattern[at + 1] === "?" ? 2 : 1, unbounded: char !== "?", varies: true, many: char !== "?" };
+  const brace = BRACE.exec(pattern.slice(at));
+  if (brace === null) return undefined;
+  const [least, most] = [Number(brace[1]), brace[2] === undefined ? Number(brace[1]) : Number(brace[3] || Infinity)];
+  return { length: brace[0].length, unbounded: most === Infinity, varies: most !== least, many: most > 1 };
+};
+
+/** Just past the "]" that closes the character class opened at pattern[at]. */
+const classEnd = (pattern: string, at: number): number => {
+  const close = CLASS_BODY.exec(pattern.slice(at + 1));
+  return close === null ? pattern.length : at + 1 + close[0].length;
+};
+
+const innermost = (scan: Scan): Group => scan.stack[scan.stack.length - 1] ?? { start: 0, varies: false, alternation: false };
+
+/** A fixed string: plain characters, and punctuation escaped (Mr\.). \d, \w and the like are classes, not literals. */
+const LITERAL = /^(?:[^\\[\](){}*+?.|^$]|\\[^A-Za-z0-9])+$/u;
+
+/**
+ * Alternatives that are plain words starting with different characters ((cat|dog)+) never compete for the same text, so
+ * repeating them is linear. Any other alternation under a repeat ((a|aa)*) may try every split of the line.
+ */
+const distinctWords = (body: string): boolean => {
+  const alternatives = body.replace(/^\?:/u, "").split("|");
+  const firsts = alternatives.map((alternative) => (alternative.startsWith("\\") ? alternative.charAt(1) : alternative.charAt(0)));
+  return alternatives.every((alternative) => LITERAL.test(alternative)) && new Set(firsts).size === firsts.length;
+};
+
+/** Whether the group's text can be split between repeats in more than one way: it varies in length, or its alternatives compete. */
+const competes = (pattern: string, closed: Group, end: number): boolean =>
+  closed.varies || (closed.alternation && !distinctWords(pattern.slice(closed.start, end - 1)));
+
+/**
+ * After an atom that ends at end (closed is the group it closes, if any). A group repeated a varying number of times, more than
+ * once ((…)+, (…)*, (…){1,10}), that can itself match in more than one way ((a+), (a{1,10}), (a|aa)) is refused.
+ */
+const afterAtom = (pattern: string, scan: Scan, end: number, closed: Group | undefined): RegexRefusal | undefined => {
+  const quantifier = quantifierAt(pattern, end);
+  scan.at = end + (quantifier?.length ?? 0);
+  const repeatsVariably = quantifier !== undefined && quantifier.varies && quantifier.many;
+  if (repeatsVariably) scan.repeats += 1;
+  if (scan.repeats > MAX_REPEATS) return "too-many-repeats";
+  // A group that can match in more than one way makes the group around it so too, quantified or not: ((a|aa))+ is (a|aa)+.
+  const closedCompetes = closed !== undefined && competes(pattern, closed, end);
+  if (closedCompetes && repeatsVariably) return "nested-quantifier";
+  if (quantifier?.varies === true || closedCompetes) innermost(scan).varies = true;
+  return undefined;
+};
+
+/** Reads one escape, class, bracket or character at scan.at. */
+const step = (pattern: string, scan: Scan): RegexRefusal | undefined => {
+  const char = pattern[scan.at];
+  if (char === "\\") return BACKREFERENCE.test(pattern.slice(scan.at)) ? "backreference" : afterAtom(pattern, scan, scan.at + 2, undefined);
+  if (char === "[") return afterAtom(pattern, scan, classEnd(pattern, scan.at), undefined);
+  if (char === "(") {
+    scan.stack.push({ start: scan.at + 1, varies: false, alternation: false });
+    scan.at += 1;
+    return undefined;
+  }
+  if (char === ")") return afterAtom(pattern, scan, scan.at + 1, scan.stack.length > 1 ? scan.stack.pop() : undefined);
+  if (char === "|") innermost(scan).alternation = true;
+  return afterAtom(pattern, scan, scan.at + 1, undefined);
+};
+
+/**
+ * A group repeated without bound that holds a repeat without bound or an alternation ((a+)+, (a|aa)*, (\w+\s?)*) is the shape
+ * that backtracks exponentially. The pattern is read once, left to right, with a stack of open groups.
+ */
+const nestedRepeat = (pattern: string): RegexRefusal | undefined => {
+  const scan: Scan = { at: 0, repeats: 0, stack: [{ start: 0, varies: false, alternation: false }] };
+  while (scan.at < pattern.length) {
+    const refusal = step(pattern, scan);
+    if (refusal !== undefined) return refusal;
+  }
+  return undefined;
+};
+
+/** Why the pattern is refused, or undefined when it may run. flags are the ones the rule runs with ("u", "iu"). */
+export const regexRefusal = (pattern: string, flags: string): RegexRefusal | undefined => {
+  if (pattern.length > MAX_PATTERN_LENGTH) return "too-long";
+  try {
+    if (new RegExp(pattern, flags).test("")) return "empty-match";
+  } catch {
+    return "invalid";
+  }
+  return nestedRepeat(pattern);
+};

package/src/custom/token-pattern.ts

@@ -0,0 +1,84 @@
+import type { Token, TokenCondition } from "../plugin.ts";
+
+// A team's morphology pattern: a run of tokens, each matching a condition on its part of speech, base form or surface.
+// 「〜を行う」 is [{ pos: 名詞 }, { surface: を }, { base: 行う }]. Pure: tokens come from the language adapter.
+
+/**
+ * Parts of speech are Universal Dependencies tags (NOUN, VERB, ADP), the same for every language. A team may also write the
+ * everyday name in Japanese or English; each maps to the tags the adapters give for it.
+ */
+const POS_NAMES: Readonly<Record<string, readonly string[]>> = {
+  名詞: ["NOUN", "PROPN", "PRON", "NUM"],
+  固有名詞: ["PROPN"],
+  代名詞: ["PRON"],
+  動詞: ["VERB"],
+  形容詞: ["ADJ"],
+  副詞: ["ADV"],
+  助詞: ["ADP", "PART", "SCONJ", "CCONJ"],
+  助動詞: ["AUX"],
+  接続詞: ["CCONJ", "SCONJ"],
+  連体詞: ["DET"],
+  記号: ["PUNCT", "SYM"],
+  noun: ["NOUN", "PROPN", "PRON"],
+  verb: ["VERB"],
+  adjective: ["ADJ"],
+  adverb: ["ADV"],
+  preposition: ["ADP"],
+  determiner: ["DET"],
+  pronoun: ["PRON"],
+  conjunction: ["CCONJ", "SCONJ"],
+  auxiliary: ["AUX"],
+};
+
+const UPOS: ReadonlySet<string> = new Set([
+  "ADJ",
+  "ADP",
+  "ADV",
+  "AUX",
+  "CCONJ",
+  "DET",
+  "INTJ",
+  "NOUN",
+  "NUM",
+  "PART",
+  "PRON",
+  "PROPN",
+  "PUNCT",
+  "SCONJ",
+  "SYM",
+  "VERB",
+  "X",
+]);
+
+/** The tags a written part of speech stands for, or undefined when chaff does not know the name. */
+export const posTags = (written: string): readonly string[] | undefined => {
+  const upper = written.toUpperCase();
+  if (UPOS.has(upper)) return [upper];
+  return POS_NAMES[written] ?? POS_NAMES[written.toLowerCase()];
+};
+
+/** The names a team may write, for the message about an unknown one. */
+export const POS_WRITTEN_NAMES: readonly string[] = [...UPOS, ...Object.keys(POS_NAMES)];
+
+const sameWord = (left: string, right: string): boolean => left.toLowerCase() === right.toLowerCase();
+
+const holds = (token: Token, condition: TokenCondition): boolean =>
+  (condition.pos === undefined || condition.pos.includes(token.pos)) &&
+  (condition.surface === undefined || sameWord(token.surface, condition.surface)) &&
+  (condition.base === undefined || sameWord(token.lemma ?? token.surface, condition.base));
+
+/** Every run of consecutive tokens where each holds its condition, as [first, last] token indexes. Runs do not overlap. */
+export const tokenRuns = (tokens: readonly Token[], conditions: readonly TokenCondition[]): (readonly [number, number])[] => {
+  if (conditions.length === 0) return [];
+  return tokens.reduce<{ runs: (readonly [number, number])[]; next: number }>(
+    (acc, _token, start) => {
+      if (start < acc.next || start + conditions.length > tokens.length) return acc;
+      const matches = conditions.every((condition, offset) => {
+        const token = tokens[start + offset];
+        return token !== undefined && holds(token, condition);
+      });
+      return matches ? { runs: [...acc.runs, [start, start + conditions.length - 1]], next: start + conditions.length } : acc;
+    },
+    { runs: [], next: 0 },
+  ).runs;
+};

package/src/detect.ts

@@ -1,4 +1,10 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
 import { japaneseRatio, latinRatio } from "./detect-language.ts";
+import { referenceListSpans } from "./reference-lists.ts";
+import { withoutSpans } from "./soft-break.ts";
 
 export type LanguageGuess = { readonly language: string; readonly confidence: number; readonly from: string };
 
@@ -8,8 +14,28 @@ export type LanguageGuess = { readonly language: string; readonly confidence: nu
  */
 const JAPANESE_FLOOR = 0.15;
 
+const HEADINGS_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "reference-headings.yaml");
+
+const isStringList = (value: unknown): value is string[] => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+const readHeadings = (): string[] => {
+  const raw: unknown = parse(readFileSync(HEADINGS_FILE, "utf8"));
+  const headings: unknown = typeof raw === "object" && raw !== null && "headings" in raw ? raw.headings : undefined;
+  if (!isStringList(headings)) throw new Error(`${HEADINGS_FILE}: headings は文字列の並びであること`);
+  return headings;
+};
+
+const REFERENCE_HEADINGS = readHeadings();
+
+/** 本文だけ。文献一覧は引いた文献の言語で書かれるので数えない。本文に字が無ければ（文献一覧だけの文書）全体。 */
+const bodyOf = (source: string): string => {
+  const body = withoutSpans(source, referenceListSpans(source, REFERENCE_HEADINGS));
+  return body.trim() === "" ? source : body;
+};
+
 export const guessLanguage = (source: string): LanguageGuess => {
-  const japanese = japaneseRatio(source);
+  const body = bodyOf(source);
+  const japanese = japaneseRatio(body);
   if (japanese >= JAPANESE_FLOOR) return { language: "ja", confidence: japanese, from: "content" };
-  return { language: "en", confidence: latinRatio(source), from: "content" };
+  return { language: "en", confidence: latinRatio(body), from: "content" };
 };

package/src/detectors/acronym-context.ts

@@ -1,7 +1,8 @@
 import { escapeRegExp } from "../orthography.ts";
-import { ROMAN_NUMERAL } from "./roman-numeral.ts";
+import { ROMAN_NUMERAL, romanRangeOf } from "./roman-numeral.ts";
 import { citationKeySpans } from "./citation-key.ts";
 import { dottedNameSpans } from "./dotted-name.ts";
+import { letterJoinedNameSpans } from "./letter-joined-name.ts";
 import { loneNumeralSpans, nameNumeralSpans } from "./name-numeral.ts";
 import { placeholderSpans } from "./placeholder.ts";
 import { seriesLabelSpans } from "./series-label.ts";
@@ -23,8 +24,12 @@ export type NotationWords = {
   readonly emphasis: readonly string[];
   /** 番号を後ろに書く、文書の区切りの名前（Part、Section、Title）。 */
   readonly divisions: readonly string[];
+  /** 番号を後ろに書く、点の付いた略した名前（Vol.、No.、FIG.）。 */
+  readonly abbreviatedLabels: readonly string[];
   /** 速記録が大文字で書く発言者の姓の前に置く敬称（Mr.、Mrs.、Madam）。 */
   readonly honorifics: readonly string[];
+  /** 大文字で書く姓の前に置く肩書き（Prime Minister、Governor）。後ろに略語も来る（the President NASA memo）ので、名前の形を求める。 */
+  readonly titles: readonly string[];
   /** 日付・時刻の数字の後ろに書く単位（年、月、日、時、分）。その前の同じ大文字の繰り返し（YY年）は書式の置き場所。 */
   readonly dateTimeUnits: readonly string[];
 };
@@ -41,14 +46,35 @@ const ANY_MERIDIEM = String.raw`[AaPp]\.?[Mm]\.?`;
 const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
 
 /**
- * 区切りの名前のすぐ後ろのローマ数字は番号（Part II、Section VIII、TITLE IV）。名前は語彙表の書き方か、全部大文字。
- * CD や CI のようにローマ数字としても読める略語は、この位置でなければ略語のまま数える。
+ * 区切りの名前や略した名前のすぐ後ろの番号（Part II、Section VIII、TITLE IV、Vol. XLIII、FIG. 3、FIGS. 1A-1C）。名前は語彙表の
+ * 書き方か、全部大文字。ローマ数字は範囲（Part II-IV）も番号。CD や CI のようにローマ数字としても読める略語は、この位置で
+ * なければ略語のまま数える。
  */
 const divisionOf = (words: readonly string[]): string => oneOf(words.flatMap((word) => [word, word.toUpperCase()]));
 
+/** 図や表の番号は短い（FIG. 3、TABLE 12、FIG. 1A）。長い数（FIG. 12345）の前の大文字は略語のまま数える。 */
+const SHORT_NUMBER = String.raw`\d{1,3}[A-Za-z]?`;
+const NUMBER_END = String.raw`(?![\p{L}\p{N}_&])`;
+
+const numberedPatterns = (words: NotationWords): readonly RegExp[] => {
+  const label = String.raw`(?<![\p{L}\p{N}_])${divisionOf([...words.divisions, ...words.abbreviatedLabels])}\s+`;
+  return [new RegExp(`${label}${romanRangeOf(ROMAN_NUMERAL)}${NUMBER_END}`, "gu"), new RegExp(`${label}${SHORT_NUMBER}${NUMBER_END}`, "gu")];
+};
+
 /** 敬称のすぐ後ろの大文字の姓（Mr. HAWLEY、Dr. O'NEIL）。速記録は発言者をこう書き、略語ではない。 */
 const SURNAME_IN_CAPITALS = String.raw`[A-Z]+(?:['’-][A-Z]+)*(?![\p{L}\p{N}_])`;
 
+/**
+ * 肩書きの後ろの大文字の語が姓と読めるのは、名前の形のときだけ。行頭の発言者の印（Senator HAWLEY.、Chairman JORDAN:）か、
+ * 日本政府の英文が「姓 名」の順に書くローマ字の名前（Prime Minister ABE Shinzo）。the President NASA memo と
+ * The Secretary GDPR: Article 5 の略語は数える。
+ */
+const GIVEN_NAME_AFTER = String.raw`(?=\s+\p{Lu}\p{Ll}+(?![\p{L}\p{N}_]))`;
+const titledName = (titles: string): readonly RegExp[] => [
+  new RegExp(String.raw`(?<=(?:^|\n)[ \t]*)${titles}\s+${SURNAME_IN_CAPITALS}(?=[.:])`, "gu"),
+  new RegExp(String.raw`(?<![\p{L}\p{N}_])${titles}\s+${SURNAME_IN_CAPITALS}${GIVEN_NAME_AFTER}`, "gu"),
+];
+
 // 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
 const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
@@ -57,8 +83,9 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
   new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
   new RegExp(oneOf(words.emphasis), "gu"),
-  new RegExp(String.raw`(?<![\p{L}\p{N}_])${divisionOf(words.divisions)}\s+${ROMAN_NUMERAL}(?![\p{L}\p{N}_&])`, "gu"),
+  ...numberedPatterns(words),
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${oneOf(words.honorifics)}\s+${SURNAME_IN_CAPITALS}`, "gu"),
+  ...titledName(oneOf(words.titles)),
 ];
 
 export type NotAcronymSpans = (text: string) => Span[];
@@ -73,6 +100,7 @@ export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
     ...patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }))),
     ...citationKeySpans(text),
     ...dottedNameSpans(text),
+    ...letterJoinedNameSpans(text),
     ...nameNumeralSpans(text),
     ...loneNumeralSpans(text),
     ...seriesLabelSpans(text),

package/src/detectors/acronym-expansion.ts

@@ -12,6 +12,7 @@ import { escapeRegExp } from "../orthography.ts";
  *   （single nucleotide polymorphism：SNP）  括弧の最後の項目が略語で、コロンの前の語の頭文字と揃う
  *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
  *   overnight reverse repurchase agreement (ON RRP)  括弧の中が空白で繋いだ略語だけで、前の名前から文字が順に拾える
+ *   Partnership On Wide Energy and Resources Resilience Asia (POWERR Asia)  括弧の中が略語と添えた語で、前の名前の頭文字と揃う
  * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
  */
 const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
@@ -149,12 +150,28 @@ const isJointBracketedAt = (body: string, acronym: string, at: number): boolean
   return abbreviates(body.slice(0, start), body.slice(start, close));
 };
 
+/** 括弧の中で略語に添えた、大文字で始まる語（(POWERR Asia)、(ZEC Initiative)）と、閉じる括弧。 */
+const QUALIFIER = new RegExp(String.raw`^(?<words>(?: [A-Z][a-z]+)+)${WRAP}[)）]`, "u");
+
+/**
+ * 括弧の中が略語と、それに添えた語だけの形。括弧の前の名前の頭文字が略語と揃うときだけ展開と見なす（(NASA Goddard) は揃わない）。
+ * 添えた語が名前の終わりにもあれば（… Resilience Asia (POWERR Asia)）、それを除いて比べる。
+ */
+const isQualifiedAt = (body: string, acronym: string, at: number): boolean => {
+  if (!OPENED.test(body.slice(Math.max(0, at - NEAR), at))) return false;
+  const end = at + acronym.length;
+  const words = QUALIFIER.exec(body.slice(end, end + DEFINITION_REACH))?.groups?.["words"];
+  if (words === undefined) return false;
+  const name = body.slice(0, at).replace(ANY_OPENED, "").trimEnd();
+  return spellsOut(name.endsWith(words) ? name.slice(0, -words.length) : name, acronym);
+};
+
 const isBracketedAt = (body: string, acronym: string, at: number): boolean => {
   const after = body.slice(at + acronym.length, at + acronym.length + NEAR);
   const before = body.slice(Math.max(0, at - NEAR), at);
   if (OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after))) return true;
   if (SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym)) return true;
-  return isSeparatedAt(body, acronym, at) || isNamedBeforeAt(body, acronym, at) || isJointBracketedAt(body, acronym, at);
+  return isSeparatedAt(body, acronym, at) || isNamedBeforeAt(body, acronym, at) || isJointBracketedAt(body, acronym, at) || isQualifiedAt(body, acronym, at);
 };
 
 /**
@@ -167,6 +184,120 @@ const EQUALS_DEFINITION = /^\s*[=＝]\s*(?=\p{L})\S*?[\p{Ll}\p{Lo}]/u;
 const isEqualsDefinedAt = (body: string, acronym: string, at: number): boolean =>
   EQUALS_DEFINITION.test(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
 
+/**
+ * 用語集の見出し語としての略語（## AFD、| AFD |、**AFD**:、- AFD —）。名前は見出し語のすぐ後ろ、つまり次の行・隣のセル・
+ * 区切りの後ろに書く。見出しと表は文にならないので、文をつないだ本文ではなく source の行を見る。
+ */
+const TERM = String.raw`[A-Z][A-Z&-]*[A-Z]`;
+const STRONG = /\*\*|__/gu;
+const LIST_MARK = String.raw`(?:[-*+]|\d+[.)])\s+`;
+const TERM_SEPARATOR = String.raw`(?:[:：]|\s[-–—]|[–—])`;
+/** 行が略語だけの見出し・段落（## AFD、AFD:、**AFD**）。 */
+const TERM_LINE = new RegExp(String.raw`^(?:#{1,6}\s+)?(?<term>${TERM})\s*(?<colon>[:：])?(?:\s+#+)?$`, "u");
+/** 見出しか強調の印。印の無い「RTO:」の行はメモの見出しにも書くので、コロンを付けた略語だけの行は印があるときだけ見出し語と読む。 */
+const MARKED_LINE = /^(?:#|\*\*|__)/u;
+/**
+ * 箇条書きの頭の略語と区切りの後ろの名前（- AFD — Area…）か、強調した略語とその後ろの名前（**AFD**: Area…、**AFD** Area…）。
+ * 印の無い行頭の略語とコロン（RTO: Review ticket ownership.）は、メモの見出しにも書くので見出し語と読まない。
+ */
+const TERM_LEAD = new RegExp(
+  String.raw`^(?:(?:${LIST_MARK})?(?<strong>\*\*|__)(?<strongTerm>${TERM})\s*(?:[:：]\s*)?\k<strong>\s*${TERM_SEPARATOR}?|${LIST_MARK}(?<term>${TERM})\s*${TERM_SEPARATOR})\s*(?<rest>\S.*)$`,
+  "u",
+);
+const TABLE_ROW = /^\s*\|.*\|\s*$/u;
+const WHOLE_TERM = new RegExp(String.raw`^${TERM}$`, "u");
+/** 名前の終わり。文の終わり、区切り、括弧、空白で挟んだハイフン。読点は名前の中にも書く（Aviation, Range, and Aerospace Meteorology）ので、その前でも比べる。 */
+const NAME_END = /[.;:：(（。|]|\s[-–—]\s|[–—]/u;
+const NAME_COMMA = /[,，、]/u;
+const LEADING_MARKS = /^[\s:：>*+-]+/u;
+
+/** 項目の頭の名前と、その読点の前まで（Service Level Agreement, a contract → Service Level Agreement）。 */
+const namesOf = (text: string): string[] => {
+  const clause = (text.replaceAll(STRONG, "").replace(LEADING_MARKS, "").split(NAME_END)[0] ?? "").trim();
+  return [clause, (clause.split(NAME_COMMA)[0] ?? "").trim()].filter((name) => name !== "");
+};
+
+/** 1 語の名前を縮めた略語（ABV → Above、ABNDT → Abundant）。名前は小文字を含む語で、略語そのもの（SEO.）ではない。 */
+const shortensWord = (name: string, acronym: string): boolean => !/\s/u.test(name) && /\p{Ll}/u.test(name) && abbreviates(name, acronym);
+
+const spellsName = (text: string, acronym: string): boolean => namesOf(text).some((name) => namesAcronym(name, acronym) || shortensWord(name, acronym));
+
+const cellsOf = (row: string): string[] =>
+  row
+    .trim()
+    .replace(/^\||\|$/gu, "")
+    .split("|")
+    .map((cell) => cell.replaceAll(STRONG, "").trim());
+
+/** 表の行で、略語だけのセルの隣（後ろか前）のセルが名前のもの。 */
+const tableTerms = (row: string): string[] => {
+  const cells = cellsOf(row);
+  return cells.filter(
+    (cell, index) => WHOLE_TERM.test(cell) && [cells[index + 1], cells[index - 1]].some((next) => next !== undefined && spellsName(next, cell)),
+  );
+};
+
+const leadTerm = (line: string): string[] => {
+  const lead = TERM_LEAD.exec(line.trim());
+  const term = lead?.groups?.["strongTerm"] ?? lead?.groups?.["term"];
+  return term !== undefined && spellsName(lead?.groups?.["rest"] ?? "", term) ? [term] : [];
+};
+
+/** 見出し語から名前までに見る行の数。空行が 2 つ挟まっても、次の段落を見る。 */
+const NEXT_LINE_REACH = 3;
+
+/** 略語だけの行と、その次の空でない行が名前のもの。 */
+const lineTerm = (lines: readonly string[], index: number): string[] => {
+  const line = (lines[index] ?? "").trim();
+  const groups = TERM_LINE.exec(line.replaceAll(STRONG, ""))?.groups;
+  const term = groups?.["term"];
+  if (term === undefined || (groups?.["colon"] !== undefined && !MARKED_LINE.test(line))) return [];
+  const next = lines.slice(index + 1, index + 1 + NEXT_LINE_REACH).find((line) => line.trim() !== "");
+  return next !== undefined && spellsName(next, term) ? [term] : [];
+};
+
+const FENCE = /^ {0,3}(?<fence>`{3,}|~{3,})/u;
+const FRONT_MATTER_EDGE = /^(?:---|\.\.\.)\s*$/u;
+
+type FenceScan = { readonly open: string | undefined; readonly kept: string[] };
+
+/** 閉じる行は記号の並びだけ。後ろに語がある行（```ts）は囲みの中の行。 */
+const CLOSING_FENCE = /^ {0,3}(?<fence>`{3,}|~{3,})\s*$/u;
+
+const closes = (line: string, open: string): boolean => CLOSING_FENCE.exec(line)?.groups?.["fence"]?.startsWith(open) === true;
+
+/** コードの囲みの中の行（開き・閉じの行も）を空にする。閉じるのは同じ記号で、開きと同じか長い並び。 */
+const withoutFences = (lines: readonly string[]): string[] =>
+  lines.reduce<FenceScan>(
+    (scan, line) => {
+      const fence = FENCE.exec(line)?.groups?.["fence"];
+      const inside = scan.open !== undefined || fence !== undefined;
+      scan.kept.push(inside ? "" : line);
+      if (scan.open === undefined) return { open: fence, kept: scan.kept };
+      return { open: closes(line, scan.open) ? undefined : scan.open, kept: scan.kept };
+    },
+    { open: undefined, kept: [] },
+  ).kept;
+
+/** 文書の頭の front matter（--- で始まり --- か ... で閉じる）の行数。無ければ 0。 */
+const frontMatterLength = (lines: readonly string[]): number =>
+  lines[0]?.trim() === "---" ? lines.findIndex((line, index) => index > 0 && FRONT_MATTER_EDGE.test(line)) + 1 : 0;
+
+/** 4 桁以上の字下げはコードとして書ける。入れ子の箇条書きと見分けずに外す（外しても、略語が報告されるほうへ倒れるだけ）。 */
+const INDENTED = /^(?: {4}|\t)/u;
+
+/** 本文として読まない行（front matter、コードの囲み、字下げしたコード）を空にした行。行の位置は変えない。 */
+const proseLines = (lines: readonly string[]): string[] => {
+  const skipped = frontMatterLength(lines);
+  return withoutFences(lines.map((line, index) => (index < skipped || INDENTED.test(line) ? "" : line)));
+};
+
+/** 用語集の見出し語として、すぐ後ろに名前を書いた略語。 */
+export const termEntryAcronyms = (source: string): ReadonlySet<string> => {
+  const lines = proseLines(source.split(/\r?\n/u));
+  return new Set(lines.flatMap((line, index) => (TABLE_ROW.test(line) ? tableTerms(line) : [...lineTerm(lines, index), ...leadTerm(line)])));
+};
+
 export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;
 
 /** body の at にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */