chaffjs 0.34.0 → 0.36.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-expansion.ts

@@ -13,6 +13,9 @@ import { escapeRegExp } from "../orthography.ts";
  *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
  *   overnight reverse repurchase agreement (ON RRP)  括弧の中が空白で繋いだ略語だけで、前の名前から文字が順に拾える
  *   Partnership On Wide Energy and Resources Resilience Asia (POWERR Asia)  括弧の中が略語と添えた語で、前の名前の頭文字と揃う
+ *   End User Technical Advisory Board (“End User TAB”)  括弧の中が名前の頭の語と略語で、前の名前の頭文字と揃う
+ *   Special Interest Groups, or SIGs  名前の後ろの読点と言い換えの語（語彙表の definition-alternative）の後ろで、名前の頭文字と揃う
+ * 複数形の s を付けた略語（SIGs）の展開は、s の無い略語（SIG）の展開でもある。
  * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
  */
 const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
@@ -37,11 +40,14 @@ const DEFINITION_REACH = 60;
 /** 定義の語どうし、定義の語と略語の間に来てよいもの（以下、HR）。英字が続けば語の途中（(theSLA)）。 */
 const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
 
+/** 複数形の略語の終わりの s（SIGs）。頭文字と比べる文字ではない。 */
+const PLURAL_END = /(?<=[A-Z])s$/u;
+
 /**
  * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
  * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
-const lettersOf = (acronym: string): string => acronym.replaceAll(/[&-]/gu, "");
+const lettersOf = (acronym: string): string => acronym.replaceAll(/[&-]/gu, "").replace(PLURAL_END, "");
 
 const initialsOf = (words: readonly string[]): string =>
   words
@@ -92,16 +98,20 @@ const isNamedBeforeAt = (body: string, acronym: string, at: number): boolean =>
   return namesAcronym(named.groups?.["name"] ?? "", acronym);
 };
 
-/** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
-export type DefinitionWords = { readonly markers: readonly string[]; readonly verbs: readonly string[] };
+/**
+ * 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）、名前の後ろの読点に続けて
+ * 略語の前に書く言い換えの語（Special Interest Groups, or SIGs の or）。
+ */
+export type DefinitionWords = { readonly markers: readonly string[]; readonly verbs: readonly string[]; readonly alternatives?: readonly string[] };
 
-type DefinitionPatterns = { readonly opened: RegExp; readonly closes: RegExp };
+type DefinitionPatterns = { readonly opened: RegExp; readonly closes: RegExp; readonly alternative: RegExp };
 
 const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : words.map(escapeRegExp).join("|"));
 
 const definitionPatterns = (words: DefinitionWords): DefinitionPatterns => ({
   opened: new RegExp(String.raw`[(（]\s*(?<markers>(?:(?:${oneOf(words.markers)})${MARKER_GAP})*)${WRAP}(?<![A-Za-z])$`, "iu"),
   closes: new RegExp(String.raw`^${WRAP}(?<verb>(?:${oneOf(words.verbs)})[。.]?)?${WRAP}[)）]`, "iu"),
+  alternative: new RegExp(String.raw`[,，、]\s*(?:${oneOf(words.alternatives ?? [])})\s*$`, "iu"),
 });
 
 /**
@@ -166,12 +176,39 @@ const isQualifiedAt = (body: string, acronym: string, at: number): boolean => {
   return spellsOut(name.endsWith(words) ? name.slice(0, -words.length) : name, acronym);
 };
 
+/** 括弧の中で略語の前に置いた、大文字で始まる語（(“End User TAB”) の End User）。 */
+const PREFIX = new RegExp(String.raw`[(（]${WRAP}(?<words>(?:[A-Z][a-z]+ )+)$`, "u");
+
+/**
+ * 括弧の中が、前の名前の頭の語と略語だけの形（End User Technical Advisory Board (“End User TAB”)）。添えた語が括弧の前の名前にあり、
+ * 名前の頭文字が略語と揃うときだけ展開と見なす。名前に無い語を添えた括弧（Review Board (“Community CRB”)）は別の名前。
+ */
+const isPrefixedAt = (body: string, acronym: string, at: number): boolean => {
+  const prefix = PREFIX.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  if (prefix === null || !CLOSES.test(body.slice(at + acronym.length, at + acronym.length + NEAR))) return false;
+  const name = body.slice(0, at - prefix[0].length);
+  const words = (prefix.groups?.["words"] ?? "").trim();
+  return name.slice(-DEFINITION_REACH).includes(words) && spellsOut(name, acronym);
+};
+
+/** 名前の後ろの読点と言い換えの語に続く略語（Special Interest Groups, or SIGs）。名前の頭文字が略語と揃うときだけ。 */
+const isAlternativeAt = (patterns: DefinitionPatterns, body: string, acronym: string, at: number): boolean => {
+  const joined = patterns.alternative.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  return joined !== null && spellsOut(body.slice(0, at - joined[0].length), 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) || isQualifiedAt(body, acronym, at);
+  return (
+    isSeparatedAt(body, acronym, at) ||
+    isNamedBeforeAt(body, acronym, at) ||
+    isJointBracketedAt(body, acronym, at) ||
+    isQualifiedAt(body, acronym, at) ||
+    isPrefixedAt(body, acronym, at)
+  );
 };
 
 /**
@@ -358,5 +395,9 @@ export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;
 /** body の at にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */
 export const expansionAt = (words: DefinitionWords): ExpandedAt => {
   const patterns = definitionPatterns(words);
-  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at) || isEqualsDefinedAt(body, acronym, at);
+  return (body, acronym, at) =>
+    isBracketedAt(body, acronym, at) ||
+    isDefinedAt(patterns, body, acronym, at) ||
+    isAlternativeAt(patterns, body, acronym, at) ||
+    isEqualsDefinedAt(body, acronym, at);
 };

package/src/detectors/acronym-known.ts

@@ -0,0 +1,40 @@
+// Words in capitals that a document itself makes known without spelling them out: a keyword of its code, a cited venue. Pure.
+import { codeFences, codeSpans, withoutCodeBlocks } from "./code-fences.ts";
+
+type Span = { readonly start: number; readonly end: number };
+
+/** A piece of code between spaces and brackets: a hyphen, a dot, a slash or an underscore keeps a name in one piece. */
+const CODE_TOKEN = /[\w./-]+/gu;
+/** A keyword: a token of letters only (select, from), not a name with parts (net-http-sspi, gsa.gov, --yjit, api_key). */
+const KEYWORD = /^[A-Za-z]+$/u;
+/** The text of an inline link ([text](url)) or of a reference link ([text][label]). */
+const LINK_TEXT = /^\[([^\]]*)\][([]/u;
+/** Capitals followed by a year: a venue and when it was held (FOSDEM 2024). */
+const VENUE_YEAR = /(?<![\w&])([A-Z][A-Z\d]+) (?:19|20)\d{2}(?!\d)/gu;
+
+/**
+ * The keywords a document's code (fenced blocks and inline code) writes in lower case, in capitals. Prose that writes a
+ * keyword of that code in capitals (a SELECT, the WHERE clause, with select and where in the code) names the keyword; it is
+ * not an acronym. A word the code too writes in capitals (`TTS`) is the acronym set as code, and gives nothing.
+ */
+export const codeWords = (source: string): Set<string> => {
+  const blocks = codeFences(source).flatMap((fence) => fence.lines);
+  const inline = codeSpans(withoutCodeBlocks(source)).map((span) => span.text);
+  const tokens = [...blocks, ...inline].flatMap((code) => code.match(CODE_TOKEN) ?? []);
+  return new Set(tokens.filter((token) => KEYWORD.test(token) && token !== token.toUpperCase()).map((token) => token.toUpperCase()));
+};
+
+/**
+ * Capitals followed by a year in a link's text (([Jane Roe, FOSDEM 2024, 18:10](https://…))): the venue of a cited talk or
+ * paper, as a reference list names one, and the link leads to it. Outside a link, a year after capitals is not read so.
+ */
+export const citedVenues = (source: string, links: readonly Span[]): Set<string> =>
+  new Set(
+    links.flatMap((link) => {
+      const text = LINK_TEXT.exec(source.slice(link.start, link.end))?.[1] ?? "";
+      return [...text.matchAll(VENUE_YEAR)].flatMap((match) => (match[1] === undefined ? [] : [match[1]]));
+    }),
+  );
+
+/** Both: the capitals a document makes known, which undefined-acronym does not ask to spell out. */
+export const knownByDocument = (source: string, links: readonly Span[]): string[] => [...codeWords(source), ...citedVenues(source, links)];

package/src/detectors/acronym-link.ts

@@ -0,0 +1,37 @@
+/**
+ * 外のページへのリンクを 1 行に 1 つ並べた一覧（参考の一覧、謝辞）の、リンクの文字。リンク先のページの題名
+ * （- [NASA Fprime AI Policy](https://…)、- [User Timing API - Web APIs | MDN](https://…)）で、書き手が展開を書き足せない。
+ * 文の中のリンク（following [NIST SP 800-61](https://…), as …）は書き手の言葉なので、略語をそのまま数える。
+ * 文書の中や手元のファイルへのリンク（[README](./README.md)）も題名ではない。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const EXTERNAL = /^<?https?:\/\//iu;
+const TEXT_END = "](";
+/** リンクの前に書いてよいもの: 行頭の空白と、箇条書きの印。 */
+const LINE_HEAD = /^[ \t]*(?:(?:[-*+]|\d+[.)])[ \t]+)?$/u;
+/** リンクの後ろに書いてよいもの: 行末までの空白と句読点。 */
+const LINE_TAIL = /^[ \t.,;。、]*(?:\n|$)/u;
+
+/** リンクの文字の範囲。[文字](行き先) の形で、行き先が外のページのものだけ。 */
+const externalTextOf = (source: string, link: Span): Span | undefined => {
+  const written = source.slice(link.start, link.end);
+  const end = written.lastIndexOf(TEXT_END);
+  if (!written.startsWith("[") || end === -1 || !EXTERNAL.test(written.slice(end + TEXT_END.length))) return undefined;
+  return { start: link.start + 1, end: link.start + end };
+};
+
+const standsAlone = (source: string, link: Span): boolean => {
+  const lineStart = source.lastIndexOf("\n", link.start - 1) + 1;
+  const lineEnd = source.indexOf("\n", link.end);
+  const tail = lineEnd === -1 ? source.slice(link.end) : source.slice(link.end, lineEnd + 1);
+  return LINE_HEAD.test(source.slice(lineStart, link.start)) && LINE_TAIL.test(tail);
+};
+
+/** 1 行に 1 つ並べた外のページへのリンクの、文字の範囲。位置は source の上。 */
+export const linkTitleSpans = (source: string, links: readonly Span[]): Span[] =>
+  links.flatMap((link) => {
+    const text = externalTextOf(source, link);
+    return text !== undefined && standsAlone(source, link) ? [text] : [];
+  });

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,140 @@
+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[];
+  /** 日本の会社の形（株式会社、㈱。語彙表 company-form）。すぐ隣の英字の語は会社の名前（㈱ADEKA、DOWAホールディングス㈱）。 */
+  readonly companyForms: 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.、SUNCALL CO.,（H.K.）LTD.）も名前の終わり。日本語の文の中の「，」も区切り（JCI(THAILAND)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)];
+};
+
+/** 日本の会社の名前の英字の語（ADEKA、DOWA）。英字の語と形のあいだに書く名前の続きの片仮名（DOWAホールディングス㈱ の ホールディングス）。 */
+const LATIN_NAME = "[A-Za-zＡ-Ｚａ-ｚ][A-Za-zＡ-Ｚａ-ｚ0-9０-９&＆]*";
+const KATAKANA_TAIL = "[ァ-ヺー・]*";
+
+/** 英字だけの形（英語の Ltd）は英字の語に続けて書かれず、続いて見えれば語の一部。漢字か片仮名を含む形だけを読む。 */
+const NOT_LATIN = /[^\p{Script=Latin}\p{P}\s]/u;
+
+/**
+ * 日本の会社の形のすぐ後ろの英字の語（㈱ADEKA、株式会社ADEKA）と、片仮名を挟んですぐ前の英字の語（ADEKA株式会社、
+ * DOWAホールディングス㈱）。名前の英字で、説明を待つ略語ではない。範囲は英字の語だけ。
+ */
+export const japaneseCompanyNameSpans = (text: string, forms: readonly string[]): Span[] => {
+  const japanese = forms.filter((form) => NOT_LATIN.test(form));
+  if (japanese.length === 0) return [];
+  const form = oneOf(japanese);
+  const after = new RegExp(`(?<=${form})${LATIN_NAME}`, "gu");
+  const before = new RegExp(`(?<![A-Za-zＡ-Ｚａ-ｚ])${LATIN_NAME}(?=${KATAKANA_TAIL}${form})`, "gu");
+  return [...spansOf(text, after), ...spansOf(text, before)];
+};
+
+/** 通貨の記号に付けた大文字（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),
+    ...japaneseCompanyNameSpans(text, words.companyForms),
+    ...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/addressee-edge.ts

@@ -0,0 +1,16 @@
+import type { Token } from "../plugin.ts";
+
+/** 連なりの尻の、宛先に付く語。surface はその語、start は文書全体の座標でその語の始まり。 */
+export type AddresseeSuffix = { readonly surface: string; readonly start: number };
+
+/**
+ * 漢字の連なり run（文書全体の座標で end に終わる）の尻が、宛先の名前に付く語（志木市役所市政情報課宛ての「宛」、御中）なら、
+ * その語。その語は名前の後ろに付くもので、名前の一部ではない。語の切れ目で始まるときだけ（宛ての語の頭が「宛」）。
+ * 折り返しをまたぐ語（御\n中）は span が surface より長いので、end から字数を引かず、end の直前の字を覆う語の始まりを使う。
+ */
+export const trailingAddressee = (tokens: readonly Token[], end: number, run: string, suffixes: readonly string[]): AddresseeSuffix | undefined => {
+  const suffix = suffixes.find((word) => word !== "" && run.length > word.length && run.endsWith(word));
+  if (suffix === undefined) return undefined;
+  const token = tokens.find((candidate) => candidate.span.start < end && end <= candidate.span.end);
+  return token !== undefined && token.surface.startsWith(suffix) ? { surface: suffix, start: token.span.start } : undefined;
+};

package/src/detectors/announced-count.ts

@@ -13,6 +13,7 @@ const countWordsOf = (doc: ProseDocument): CountWords => ({
   frames: patternsOf(doc, "count-frame"),
   hedgesBefore: patternsOf(doc, "count-hedge", "before"),
   hedgesAfter: patternsOf(doc, "count-hedge", "after"),
+  titles: patternsOf(doc, "count-title"),
 });
 
 const memberGroup = (doc: ProseDocument, group: string): string[] =>

package/src/detectors/bare-comparative.ts

@@ -1,12 +1,15 @@
 import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { quotedIn } from "../quoted-span.ts";
 import { followsInlineCode } from "./code-before.ts";
+import { isNamedStep, plainStepKeys } from "./graded-step.ts";
 
 /**
  * 比べる相手の無い比較（より良い結果、さらに高速に、The new engine is faster.）。何より良いのか、何より速いのかが書かれていない。
  * 語は語彙表 comparative-baseline が言う。group marker は日本語の比べる副詞（より、さらに）、more は英語の比べる語、comparative は比べた形の語
  * （faster、better）、baseline は相手を言う語（従来、以前、than、previous）、exempt は比較でない決まった言い方（より多くの、より詳しく）、
  * condition は比較を条件や仮定の下に置く語（使うと、if、would）。条件を書いた比較は、その条件の無い場合と比べている。
+ * beyond は比べた形のすぐ前で、いま述べたものを越えると言う語（even better、still faster）。相手はその直前に書いてある。
+ * aim は比べた語の後ろで、今より良くする目当てを言う語（より良い社会、より良いものにする）。比べる相手は今の状態。
  * 同じ文か前の二文に相手を言う語があれば、相手は書いてある。
  */
 
@@ -17,6 +20,8 @@ export type ComparativeLists = {
   readonly baselines: readonly string[];
   readonly exempt: ReadonlySet<string>;
   readonly conditions: ReadonlySet<string>;
+  readonly beyond: ReadonlySet<string>;
+  readonly aims: ReadonlySet<string>;
 };
 
 export type BareComparative = { readonly first: Token; readonly last: Token };
@@ -44,13 +49,35 @@ const isGradable = (tokens: readonly Token[], at: number): boolean => {
 /** 比べる副詞が語の頭に立つか。前が助詞・記号・接続の語か文の頭のときだけ（「学年だより等」の「より」は語の一部）。 */
 const OPENS_WORD = new Set(["ADP", "PUNCT", "SCONJ", "CCONJ", "ADV"]);
 
-/** 日本語: 副詞の「より」「さらに」の直後の、程度を言える語。比較の決まった言い方（より多くの）は除く。 */
+/** 語から続く語をつないだもの（もの、ものに、ものにする）と、それぞれの後ろの語の位置。 */
+const MAX_AIM_TOKENS = 3;
+const runsFrom = (tokens: readonly Token[], at: number): { readonly run: string; readonly after: number }[] =>
+  tokens
+    .slice(at, at + MAX_AIM_TOKENS)
+    .reduce<{ run: string; after: number }[]>(
+      (runs, token, index) => [...runs, { run: `${runs.at(-1)?.run ?? ""}${token.surface}`, after: at + index + 1 }],
+      [],
+    );
+
+/** 続く語に名詞が付いて、より長い語の頭になっているか（社会保障の「社会」）。 */
+const headsCompound = (tokens: readonly Token[], after: number): boolean => {
+  const [last, next] = [tokens[after - 1], tokens[after]];
+  return last?.pos === "NOUN" && next?.pos === "NOUN" && last.span.end === next.span.start;
+};
+
+/** 程度を言う語（at）の後ろが、今より良くする目当てか（より良い社会、より豊かな暮らし、より良いものにする）。 */
+const namesAim = (tokens: readonly Token[], at: number, aims: ReadonlySet<string>): boolean => {
+  const next = tokens[at]?.pos === "NOUN" && ADJECTIVAL_TAIL.has(tokens[at + 1]?.surface ?? "") ? at + 2 : at + 1;
+  return runsFrom(tokens, next).some(({ run, after }) => aims.has(run) && !headsCompound(tokens, after));
+};
+
+/** 日本語: 副詞の「より」「さらに」の直後の、程度を言える語。比較の決まった言い方（より多くの）と、今より良くする目当て（より良い社会）は除く。 */
 const markedAt = (tokens: readonly Token[], at: number, lists: ComparativeLists): BareComparative | undefined => {
   const [marker, word] = [tokens[at], tokens[at + 1]];
   if (marker?.pos !== "ADV" || !lists.markers.has(marker.surface) || word === undefined || lists.exempt.has(word.surface)) return undefined;
   const previous = tokens[at - 1];
   if (previous !== undefined && !OPENS_WORD.has(previous.pos)) return undefined;
-  return isGradable(tokens, at + 1) ? { first: marker, last: word } : undefined;
+  return isGradable(tokens, at + 1) && !namesAim(tokens, at + 1, lists.aims) ? { first: marker, last: word } : undefined;
 };
 
 /** 比べた形の後ろで節が終わるか。読点の後ろに形容詞が続けば、名詞の前に並べた修飾語（better, more predictable results）。 */
@@ -87,10 +114,16 @@ const predicateAt = (tokens: readonly Token[], at: number, lists: ComparativeLis
 const isConditional = (tokens: readonly Token[], found: BareComparative, conditions: ReadonlySet<string>): boolean =>
   tokens.some((token) => token.span.start < found.first.span.start && token.pos !== "CCONJ" && conditions.has(lower(token)));
 
+/** 比べた形のすぐ前が、いま述べたものを越えると言う語か（performed even better）。 */
+const goesBeyond = (tokens: readonly Token[], found: BareComparative, beyond: ReadonlySet<string>): boolean => {
+  const before = tokens.findLastIndex((token) => token.span.end <= found.first.span.start);
+  return beyond.has(lower(tokens[before]));
+};
+
 export const bareComparativesIn = (tokens: readonly Token[], lists: ComparativeLists): BareComparative[] =>
   tokens
     .flatMap((_, at) => markedAt(tokens, at, lists) ?? predicateAt(tokens, at, lists) ?? [])
-    .filter((found) => !isConditional(tokens, found, lists.conditions));
+    .filter((found) => !isConditional(tokens, found, lists.conditions) && !goesBeyond(tokens, found, lists.beyond));
 
 /**
  * 語が比べる相手を言う語か。語の形か原形で照らし、一字の語（旧）は語の頭だけ（旧版は相手、復旧は相手でない）。
@@ -128,6 +161,8 @@ export const listsOf = (lexicon: Lexicon): ComparativeLists => ({
   baselines: groupOf(lexicon, "baseline"),
   exempt: new Set(groupOf(lexicon, "exempt")),
   conditions: new Set(groupOf(lexicon, "condition")),
+  beyond: new Set(groupOf(lexicon, "beyond")),
+  aims: new Set(groupOf(lexicon, "aim")),
 });
 
 /** 鉤括弧の中の比較（「給与所得の確定申告がさらに簡単に！」ページ）は題や語を挙げたもので、書き手の比較ではない。 */
@@ -139,12 +174,18 @@ const isThanAfterCode = (doc: ProseDocument, found: BareComparative): boolean =>
 
 export const bareComparative: Detector = (doc): Finding[] => {
   const lists = listsOf(doc.lexicons["comparative-baseline"] ?? []);
+  const steps = plainStepKeys(
+    doc.sentences.map((sentence) => ({ tokens: sentence.tokens ?? [], quoted: quotedIn(sentence) })),
+    lists.markers,
+    isGradable,
+  );
   return doc.sentences.flatMap((sentence, at) => {
     const nearby = doc.sentences.slice(Math.max(0, at - BASELINE_REACH), at + 1);
     if (sentence.embeddedLanguage !== undefined || nearby.some((near) => namesBaseline(near, lists.baselines))) return [];
     const quoted = quotedIn(sentence);
     return bareComparativesIn(sentence.tokens ?? [], lists)
       .filter((found) => !quoted.some((span) => insideSpan(found, span)) && !isThanAfterCode(doc, found))
+      .filter((found) => !lists.markers.has(found.first.surface) || !isNamedStep(sentence.tokens ?? [], found.last, steps))
       .map((found) => ({
         rule: "",
         severity: "info",