chaffjs 0.35.0 → 0.37.0

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,46 @@ 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);
+};
+
+/** 引用符で囲んで書き終えた名前（‘abstract syntax tree’）。小文字の語でも、囲みが名前の始まりと終わりを決める。 */
+const QUOTED_NAME_END = /(?:“(?<curly>[^“”\n]{1,60})”|‘(?<single>[^‘’\n]{1,60})’|"(?<straight>[^"\n]{1,60})")$/u;
+
+/** 名前の後ろの読点と言い換えの語に続く略語（Special Interest Groups, or SIGs、‘abstract syntax tree’, or ‘AST’）。名前の頭文字が略語と揃うときだけ。 */
+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));
+  if (joined === null) return false;
+  const name = body.slice(0, at - joined[0].length);
+  const groups = QUOTED_NAME_END.exec(name)?.groups;
+  const quoted = groups?.["curly"] ?? groups?.["single"] ?? groups?.["straight"];
+  return spellsOut(name, acronym) || (quoted !== undefined && namesAcronym(quoted, 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 +402,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,75 @@
+/**
+ * 外のページへのリンクを 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] : [];
+  });
+
+/** 語だけの箇条書きの項目（- GPL）と、その下に入れ子にした、外のページへのリンクだけの項目（  - [GNU General Public License …](https://…)）。 */
+const TERM_ITEM = /^(?<indent>[ \t]*)(?:[-*+]|\d+[.)])[ \t]+(?<term>[A-Z][A-Za-z\d&-]*[A-Z\d])[ \t]*$/u;
+const LINK_ITEM = /^(?<indent>[ \t]*)(?:[-*+]|\d+[.)])[ \t]+\[(?<title>[^\]\n]+)\]\(<?https?:\/\/[^)\s]+>?\)[ \t]*$/u;
+/** 題名の名前の終わり。サイトの名前を添える区切り（ | Open Source Initiative、 — CC BY 4.0）。 */
+const TITLE_PART_END = /\s[|—–-]\s/u;
+const CAPITALIZED = /^[A-Z]/u;
+
+const wordsOf = (text: string): string[] => text.split(/[\s-]+/u).filter((word) => word !== "");
+
+/** 題名が語そのものを含む（About the WTFPL、… — CC BY 4.0）か、題名の名前の大文字で始まる語の頭文字が語の字で終わる（GNU General Public License）。 */
+const titleNames = (title: string, term: string): boolean => {
+  const termWords = wordsOf(term.toUpperCase());
+  const titleWords = wordsOf(title.toUpperCase());
+  const contains = titleWords.some((_, start) => termWords.every((word, offset) => titleWords[start + offset] === word));
+  const initials = wordsOf(title.split(TITLE_PART_END)[0] ?? "")
+    .filter((word) => CAPITALIZED.test(word))
+    .map((word) => word.charAt(0))
+    .join("");
+  return contains || initials.endsWith(term.replaceAll(/[&-]/gu, ""));
+};
+
+/**
+ * 名前を並べた一覧で、語だけの項目のすぐ下に、その語を名指す外のページへのリンクを入れ子にした語（ライセンスの一覧の GPL、WTFPL）。
+ * 語はリンク先のページの名前で、読み手はリンクから中身に行ける。題名が語を名指さないリンク（- AWS / - [Console](…)）では数えない。
+ */
+export const linkedListTerms = (source: string): Set<string> => {
+  const lines = source.split(/\r?\n/u);
+  return new Set(
+    lines.flatMap((line, index) => {
+      const term = TERM_ITEM.exec(line)?.groups;
+      const link = LINK_ITEM.exec(lines[index + 1] ?? "")?.groups;
+      if (term?.["term"] === undefined || link?.["title"] === undefined) return [];
+      const nested = (link["indent"] ?? "").length > (term["indent"] ?? "").length;
+      return nested && titleNames(link["title"], term["term"]) ? [term["term"]] : [];
+    }),
+  );
+};

package/src/detectors/acronym-mention.ts

@@ -0,0 +1,44 @@
+// Acronyms a sentence about abbreviations spells out in words (the abbreviation DOB … spell out the field to date of birth),
+// and the other capitalisations of an acronym that a text writes (TCoP beside TCOP). Pure; the mention words come from the
+// abbreviation-mention lexicon.
+import { escapeRegExp } from "../orthography.ts";
+
+const ACRONYM = /(?<![\p{L}\p{N}])[A-Z][A-Z&-]*[A-Z](?![\p{L}\p{N}])/gu;
+/** A word of two letters or more: the letters of a dotted form (B.B.C.) spell nothing out. */
+const LATIN_WORD = /[A-Za-z]{2,}/gu;
+const CAPITAL = /\p{Lu}/gu;
+/** A capitalisation of an acronym keeps at least this many capitals (TCoP); fewer is a word (Tcop). */
+const MIN_CAPITALS = 2;
+
+const mentionsAbbreviation = (sentence: string, mentions: readonly string[]): boolean => {
+  const lowered = sentence.toLowerCase();
+  return mentions.some((mention) => lowered.includes(mention.toLowerCase()));
+};
+
+/** Whether some run of consecutive words, other than the acronym itself, has the acronym's letters as its initials. */
+const spellsOutInWords = (sentence: string, acronym: string): boolean => {
+  const letters = acronym.replaceAll(/[&-]/gu, "").toLowerCase();
+  const words = (sentence.match(LATIN_WORD) ?? []).filter((word) => word !== acronym.replaceAll(/[&-]/gu, ""));
+  return words.some(
+    (_, start) =>
+      words
+        .slice(start, start + letters.length)
+        .map((word) => word.charAt(0).toLowerCase())
+        .join("") === letters,
+  );
+};
+
+/** The acronyms that a sentence naming an abbreviation also writes out in full. */
+export const spelledOutAcronyms = (sentences: readonly string[], mentions: readonly string[]): Set<string> =>
+  new Set(
+    sentences
+      .filter((sentence) => mentionsAbbreviation(sentence, mentions))
+      .flatMap((sentence) => (sentence.match(ACRONYM) ?? []).filter((acronym) => spellsOutInWords(sentence, acronym))),
+  );
+
+/** The other ways the text capitalises an acronym (TCoP for TCOP, TCOP for TCoP), each with two capitals or more. */
+export const caseVariantsIn = (text: string, acronym: string): string[] => {
+  const written = new RegExp(String.raw`(?<![\p{L}\p{N}])${escapeRegExp(acronym)}(?![\p{L}\p{N}])`, "giu");
+  const variants = [...text.matchAll(written)].map((match) => match[0]);
+  return [...new Set(variants)].filter((variant) => variant !== acronym && (variant.match(CAPITAL) ?? []).length >= MIN_CAPITALS);
+};

package/src/detectors/acronym-name.ts

@@ -12,6 +12,8 @@ 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）。 */
@@ -44,28 +46,48 @@ export const oneOf = (words: readonly string[]): string =>
 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}&.'’-]*`;
+/** 名前の語。大文字か、数字に続く字で始まり（37signals）、点・& ・アポストロフィ・ハイフンを含んでよい（BorrowMoney.com、PTE.、O'Neil）。 */
+const NAME_WORD = String.raw`(?:\p{Lu}|\p{N}+\p{L})[\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）。
+ * 名前に続けて書いた括弧のすぐ後ろの形（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 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");
 
@@ -108,6 +130,7 @@ 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),

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/addressee-title-edge.ts

@@ -0,0 +1,39 @@
+import type { Token } from "../plugin.ts";
+
+/**
+ * 宛名の並び（各国公私立高等専門学校長、公益財団法人日本博物館協会会長）の、名前の外の語。頭の「各」（語彙表 addressee-prefix）と、
+ * 尻の役職（addressee-title: 長、会長、教育長）。endings は組織の名前を閉じる語（organisation-unit）、forms は法人格（organisation-form）。
+ */
+export type AddresseeWords = {
+  readonly prefixes: readonly string[];
+  readonly titles: readonly string[];
+  readonly endings: readonly string[];
+  readonly forms: readonly string[];
+};
+
+/** 組織の語の前に要る字数。1 字なら、普通の語の一部（本部、学校）と見分けられない。 */
+const MIN_BODY_LENGTH = 2;
+
+const charLength = (text: string): number => [...text].length;
+
+/** 名前が組織の語（2 字以上の名の後ろの協会、学校）か法人格（独立行政法人）で閉じるか。 */
+export const endsInOrganisation = (name: string, words: AddresseeWords): boolean =>
+  words.forms.some((form) => name.endsWith(form)) ||
+  words.endings.some((unit) => name.endsWith(unit) && charLength(name) - charLength(unit) >= MIN_BODY_LENGTH);
+
+/** 尻の役職のうち、残りが組織の名前で閉じる最も長いもの（機構長 > 長）。役職だけの連なりや、組織で閉じないもの（延長、成長）は undefined。 */
+export const trailingTitle = (run: string, words: AddresseeWords): string | undefined =>
+  words.titles
+    .filter((title) => run.length > title.length && run.endsWith(title) && endsInOrganisation(run.slice(0, run.length - title.length), words))
+    .reduce<string | undefined>((longest, title) => (title.length > (longest?.length ?? 0) ? title : longest), undefined);
+
+/**
+ * 連なり（文書全体の座標で start から始まる）の頭の「各」の語。その語が連なりの頭にあり、残り（name: 役職を外した連なり）が
+ * 組織の名前で閉じるときだけ。各国の「各」のような語の一部は、解析が別の語に分けたときしか外さない。
+ */
+export const leadingPrefix = (tokens: readonly Token[], start: number, name: string, words: AddresseeWords): Token | undefined => {
+  const token = tokens.find((candidate) => candidate.span.start === start);
+  if (token === undefined || !words.prefixes.includes(token.surface)) return undefined;
+  const rest = name.slice(token.surface.length);
+  return name.startsWith(token.surface) && rest !== "" && endsInOrganisation(rest, words) ? token : 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",

package/src/detectors/blank-structure.ts

@@ -8,6 +8,7 @@ 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, withoutLeadingBlankCells } from "../structure/total.ts";
+import { isSpannedLabelGap } from "../structure/spanned-label-blank.ts";
 
 /** Fewer body rows than this, and one blank is as likely a choice as a gap. */
 const MIN_BODY_ROWS = 3;
@@ -67,8 +68,6 @@ const cellOffset = (cell: MarkdownNode | undefined, row: MarkdownNode | undefine
 /** Whether a row is a total, subtotal or tax row, judged from the row's source text. */
 export type IsTotalRow = (rowText: string) => boolean;
 
-const NO_TOTAL_ROWS: IsTotalRow = () => false;
-
 const rowSource = (source: string, row: MarkdownNode): string => {
   const span = spanOf(row);
   return span === undefined ? "" : source.slice(span.start, span.end);
@@ -79,30 +78,40 @@ const bodyRowOf = (source: string, row: MarkdownNode, isTotalRow: IsTotalRow): B
   cells: (row.children ?? []).map((cell) => (shows(cell) ? sourceOf(source, cell) : undefined)),
 });
 
+/** How a table's rows are read: which rows are totals, and the total words that make a cell a row label (Total score). */
+type TableReading = { readonly isTotalRow: IsTotalRow; readonly totalWords: readonly string[] };
+
+const NO_TOTALS: TableReading = { isTotalRow: () => false, totalWords: [] };
+
 /**
  * The one blank body cell of a column whose other body rows are all filled, unless it is a total row's blank beside its
- * amount. Such a blank still counts as a second blank, so the rows it shares a column with stay as unreported as before.
+ * amount, or the second column of a label that spans two (| Total score |  | 5 |). Such a blank still counts as a second
+ * blank, so the rows it shares a column with stay as unreported as before.
  */
-const columnBlank = (source: string, header: MarkdownNode, body: readonly MarkdownNode[], rows: readonly BodyRow[], column: number): Blank[] => {
+const columnBlank = (source: string, table: TableRows, totalWords: readonly string[], column: number): Blank[] => {
+  const { header, body, rows } = table;
   const blanks = rows.flatMap((row, index) => (row.cells[column] === undefined ? [index] : []));
   const at = blanks[0];
   const row = at === undefined ? undefined : rows[at];
   if (blanks.length !== 1 || at === undefined || row === undefined) return [];
   if (isTotalRowGap(row, column, amountColumnOf(rows, header.children?.length ?? 0))) return [];
+  if (isSpannedLabelGap(row.cells, column, totalWords)) return [];
   const offset = cellOffset(body[at]?.children?.[column], body[at]);
   const name = sourceOf(source, header.children?.[column]);
   return offset === undefined || name === "" ? [] : [{ offset, name }];
 };
 
+type TableRows = { readonly header: MarkdownNode; readonly body: readonly MarkdownNode[]; readonly rows: readonly BodyRow[] };
+
 /** The first column is skipped: a blank there often means "same as above". */
-const tableBlanksOf = (source: string, table: MarkdownNode, isTotalRow: IsTotalRow): Blank[] => {
+const tableBlanksOf = (source: string, table: MarkdownNode, reading: TableReading): Blank[] => {
   const [header, ...body] = table.children ?? [];
   if (header === undefined || body.length < MIN_BODY_ROWS) return [];
-  const rows = body.map((row) => bodyRowOf(source, row, isTotalRow));
+  const rows = body.map((row) => bodyRowOf(source, row, reading.isTotalRow));
   const columns = header.children?.length ?? 0;
   return Array.from({ length: columns }, (_unused, column) => column)
     .slice(1)
-    .flatMap((column) => columnBlank(source, header, body, rows, column));
+    .flatMap((column) => columnBlank(source, { header, body, rows }, reading.totalWords, column));
 };
 
 /** Quoted material is someone else's: email replies the document model found, and every Markdown blockquote. */
@@ -118,8 +127,8 @@ const blocksOutsideQuotes = (source: string, type: string, replies: readonly Spa
 };
 
 /** Blank cells in every table outside quotes. */
-export const tableBlanks = (source: string, replies: readonly Span[] = [], isTotalRow: IsTotalRow = NO_TOTAL_ROWS): Blank[] =>
-  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table, isTotalRow));
+export const tableBlanks = (source: string, replies: readonly Span[] = [], reading: TableReading = NO_TOTALS): Blank[] =>
+  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table, reading));
 
 type Item = { readonly node: MarkdownNode; readonly text: string | undefined; readonly empty: boolean };
 
@@ -192,5 +201,7 @@ const totalRowOf = (doc: ProseDocument): IsTotalRow => {
   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)));
+export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) =>
+  tableBlanks(doc.source, doc.replyQuotes ?? [], { isTotalRow: totalRowOf(doc), totalWords: patternsOf(doc, "total-label") }),
+);
 export const emptyListItem: Detector = findingsOf("empty-list-item", (doc) => listBlanks(doc.source, doc.replyQuotes ?? []));

package/src/detectors/bracket-specified.ts

@@ -0,0 +1,25 @@
+import { asideAt } from "./open-end-names.ts";
+
+// A vague word pinned down by the bracket right after it: 一定の事項（インボイスに記載が必要な事項）, a reasonable fee (USD 50).
+// The aside says what the word leaves open, so the word is not vague there. An aside that only gives the phrase a name
+// (以下「措置」という, hereinafter the "Fee") pins nothing down. Pure: the words that start a name come in.
+
+/** What may stand between the vague word and the bracket: the noun it qualifies (事項, fee), no punctuation. */
+const BEFORE_BRACKET = /^[\p{L}\p{N}\p{M} ]{0,12}?(?=[（(])/u;
+
+const startsWithName = (aside: string, nameMarkers: readonly string[]): boolean => {
+  const lower = aside.trimStart().toLowerCase();
+  return nameMarkers.some((marker) => marker !== "" && lower.startsWith(marker.toLowerCase()));
+};
+
+/**
+ * Whether the words right after end (an offset in text) are pinned down by a bracket: at most a short noun, then an
+ * aside that opens and closes and holds more than a name. nameMarkers: the words that start a name (以下, hereinafter).
+ */
+export const specifiedByBracket = (text: string, end: number, nameMarkers: readonly string[]): boolean => {
+  const rest = text.slice(end);
+  const before = BEFORE_BRACKET.exec(rest);
+  if (before === null) return false;
+  const aside = asideAt(text, end + before[0].length);
+  return aside !== undefined && aside.trim() !== "" && !startsWithName(aside, nameMarkers);
+};