chaffjs 0.15.0 → 0.17.0

package/src/commands/tree.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
 import { profileFor } from "../profile/for-file.ts";
+import { resolveGenre } from "../resolve-genre.ts";
 import { guessLanguage } from "../detect.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
 import { buildStructure } from "../structure/of.ts";
@@ -35,15 +36,15 @@ const TEXT: Texts<{
   },
 };
 
-export const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
+const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
 
-const FORMATS = ["sexp", "json"];
+const FORMATS: ReadonlySet<string> = new Set(["sexp", "json"]);
 
 /** 値を取るフラグ。その次の引数は値で、対象のファイルではない。 */
-const VALUED = ["--format", "--language"];
+const VALUED: ReadonlySet<string> = new Set(["--format", "--language", "--genre"]);
 
 export const treeTargets = (argv: readonly string[]): string[] =>
-  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.includes(all[index - 1] ?? ""));
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
 
 export const readSource = async (path: string, context: TreeContext): Promise<string | undefined> => {
   try {
@@ -81,7 +82,7 @@ export const readTree = async (path: string, argv: readonly string[], context: T
   }
   // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
   await adapter.prepare?.({ pos: true });
-  const profile = profileFor(context.config, path, source, language);
+  const profile = profileFor(context.config, path, source, language, resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre);
   return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile }, adapter.structure) };
 };
 
@@ -108,7 +109,7 @@ export const inOrder = async (paths: readonly string[], each: (path: string) =>
  */
 export const runTree = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
   const format = context.flag(argv, "--format") ?? "sexp";
-  if (paths.length === 0 || !FORMATS.includes(format)) {
+  if (paths.length === 0 || !FORMATS.has(format)) {
     console.error(treeText(context).usage);
     return 1;
   }

package/src/config/by-path.ts

@@ -44,12 +44,11 @@ export const matches = (glob: string, base: string, path: string): boolean => to
 type PathSettings = { genre?: string; language?: string; profile?: string };
 
 export const applyByPath = (rules: readonly PathRule[], base: string, path: string): PathSettings =>
-  rules.reduce<PathSettings>((acc, rule) => {
-    if (!rule.files.some((glob) => matches(glob, base, path))) return acc;
-    return {
-      ...acc,
-      ...(rule.genre === undefined ? {} : { genre: rule.genre }),
-      ...(rule.language === undefined ? {} : { language: rule.language }),
-      ...(rule.profile === undefined ? {} : { profile: rule.profile }),
-    };
-  }, {});
+  rules
+    .filter((rule) => rule.files.some((glob) => matches(glob, base, path)))
+    .reduce<PathSettings>((settings, rule) => {
+      if (rule.genre !== undefined) settings.genre = rule.genre;
+      if (rule.language !== undefined) settings.language = rule.language;
+      if (rule.profile !== undefined) settings.profile = rule.profile;
+      return settings;
+    }, {});

package/src/config/load.ts

@@ -30,6 +30,10 @@ export type Config = {
   readonly prefer: Readonly<Record<string, string>>;
   /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
   readonly requiredSections: readonly string[];
+  /** チームの固有名詞（組織名・製品名）。1 つの名前として読み、漢字の連なりや繰り返しに数えない。 */
+  readonly names: readonly string[];
+  /** names に書かれていたが名前として読めなかった値。黙って捨てると、並べたつもりの名前が効いていないことに気づけない。 */
+  readonly unreadableNames: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -54,6 +58,8 @@ export const EMPTY: Config = {
   jargon: [],
   prefer: {},
   requiredSections: [],
+  names: [],
+  unreadableNames: [],
   byPath: [],
   baseDir: process.cwd(),
 };
@@ -114,6 +120,21 @@ const preferOf = (raw: unknown): Record<string, string> =>
       )
     : {};
 
+const isNameEntry = (value: unknown): value is string | number => typeof value === "string" || typeof value === "number";
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** 名前は文字列か数（2025 のような名前）の並び。並びでない値と、並びの中の名前でない項目は読めないものとして返す。 */
+const namesOf = (raw: unknown): { readonly names: string[]; readonly unreadable: string[] } => {
+  if (raw === undefined || raw === null) return { names: [], unreadable: [] };
+  if (!Array.isArray(raw)) return { names: [], unreadable: [printed(raw)] };
+  const entries: unknown[] = raw;
+  return {
+    names: wordsOf(entries.filter(isNameEntry)),
+    unreadable: entries.filter((entry) => !isNameEntry(entry)).map(printed),
+  };
+};
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -122,6 +143,7 @@ export const loadConfig = (path: string): Config => {
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
+  const names = namesOf(raw["names"]);
   return {
     genre: str(raw["genre"]),
     profile: str(raw["profile"]),
@@ -137,6 +159,8 @@ export const loadConfig = (path: string): Config => {
     jargon: wordsOf(raw["jargon"]),
     prefer: preferOf(raw["prefer"]),
     requiredSections: wordsOf(raw["required_sections"]),
+    names: names.names,
+    unreadableNames: names.unreadable,
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
   };

package/src/config/name-problems.ts

@@ -0,0 +1,15 @@
+import type { Config } from "./load.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly unreadable: (where: string, value: string) => string }> = {
+  ja: {
+    unreadable: (where, value) => `${where}: names の ${value} は名前として読めません。names には名前を 1 行に 1 つずつ並べてください（- 個人情報保護委員会）`,
+  },
+  en: {
+    unreadable: (where, value) => `${where}: cannot read ${value} under names as a name. Write names as a list, one name per line (- Bank of England)`,
+  },
+};
+
+/** chaff.yaml の names のうち、名前として読めなかったもの。読めないまま黙ると、書いた人は名前を並べたつもりで何も変わっていない。 */
+export const nameProblems = (config: Pick<Config, "unreadableNames" | "path">, ui: UiLanguage = "ja"): string[] =>
+  config.unreadableNames.map((value) => TEXT[ui].unreadable(config.path ?? "chaff.yaml", value));

package/src/date-stamp.ts

@@ -21,7 +21,7 @@ const LABEL_EDGE = /[\s:：]/u;
 const datesOf = (candidate: StampCandidate): Span[] => candidate.dates.filter((date) => date.end > date.start);
 
 const withoutDates = (candidate: StampCandidate): string => {
-  const ordered = datesOf(candidate).sort((left, right) => left.start - right.start);
+  const ordered = datesOf(candidate).toSorted((left, right) => left.start - right.start);
   const gaps = ordered.reduce<{ readonly parts: readonly string[]; readonly from: number }>(
     (acc, date) => ({ parts: [...acc.parts, candidate.text.slice(acc.from, date.start)], from: Math.max(acc.from, date.end) }),
     { parts: [], from: 0 },

package/src/detectors/acronym-context.ts

@@ -2,6 +2,7 @@ import { escapeRegExp } from "../orthography.ts";
 import { ROMAN_NUMERAL } 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";
@@ -25,6 +26,8 @@ export type NotationWords = {
   readonly divisions: 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[];
 };
@@ -49,6 +52,17 @@ const divisionOf = (words: readonly string[]): string => oneOf(words.flatMap((wo
 /** 敬称のすぐ後ろの大文字の姓（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"),
@@ -59,6 +73,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   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"),
   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 +88,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 にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */

package/src/detectors/agreement-slip.ts

@@ -0,0 +1,191 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { isPartOfLongerWord } from "./doubled-word.ts";
+
+/**
+ * 語の形が合っていない（a significant changes / one of the most important feature / Your can check）。
+ * 書き換えで片方の語だけ直した跡。解析器の読みが一通りに決まる形だけを数える。語はすべてアダプタの語彙表から来る。
+ */
+
+export type AgreementLists = {
+  /** 一つを数える限定詞（a / each）。 */
+  readonly singular: Lexicon;
+  /** 複数を数える限定詞と句（these / one of the）。 */
+  readonly plural: Lexicon;
+  /** 単数と複数が同じ綴りの名詞（series / data）。 */
+  readonly invariant: ReadonlySet<string>;
+  /** 単数の限定詞で複数を数える形容詞（a few days）。 */
+  readonly count: ReadonlySet<string>;
+  /** 名詞の前にしか立たない所有の語（your / their）。 */
+  readonly possessive: ReadonlySet<string>;
+  /** 名詞にならない be / have の形（is / has）。 */
+  readonly finite: ReadonlySet<string>;
+  /** 単数で書く所を複数で書いた句（ones of the most）。 */
+  readonly misnumbered: Lexicon;
+};
+
+export type Slip = { readonly variant: "number" | "possessive"; readonly first: Token; readonly last: Token; readonly word: string };
+
+const SPACE_ONLY = /^\s+$/u;
+const UPPER_START = /^\p{Lu}/u;
+const LETTER = /\p{L}/u;
+const LOWER = /\p{Ll}/u;
+/** 名詞句を閉じる記号。読点・括弧の始まり・ハイフンは、名詞を重ねた語（a sales, marketing and support team）の途中にも立つ。 */
+const CLOSING_MARK = new Set([".", ";", ":", "?", "!", ")"]);
+/**
+ * 名詞の後ろに来れば、名詞句はそこで終わっている品詞。名詞・形容詞・接続詞・所有の印は、名詞を重ねた語の途中。
+ * 動詞は、名詞にならない be / have の形（is / has）だけ。解析器は複数の名詞の後ろの名詞を動詞と読む（a sales team の team が VBP）。
+ */
+const PHRASE_END = new Set(["AUX", "ADP", "SCONJ", "PRON", "DET", "ADV"]);
+const PREDICATE_TAIL = new Set(["DET", "ADJ", "PRON", "NUM"]);
+
+const lower = (token: Token): string => token.surface.toLowerCase();
+
+const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part" || token.features?.["VerbForm"] === "Ger";
+
+const isArticle = (token: Token): boolean => token.features?.["PronType"] === "Art";
+
+const isPlural = (token: Token): boolean => token.features?.["Number"] === "Plur";
+
+/** 名詞の後ろの語で、名詞句が終わるか。分詞（a data driven approach）も名詞を重ねた語の途中。 */
+export const endsNounPhrase = (next: Token | undefined, finite: ReadonlySet<string>): boolean => {
+  if (next === undefined || finite.has(lower(next))) return true;
+  return next.pos === "PUNCT" ? CLOSING_MARK.has(next.surface) : PHRASE_END.has(next.pos);
+};
+
+const wordsOf = (entry: Lexicon[number]): readonly string[] =>
+  entry.tokens === undefined ? entry.pattern.toLowerCase().split(/\s+/u) : entry.tokens.map((token) => token.surface.toLowerCase());
+
+/** tokens の at 語目から始まる語彙表の句の長さ。無ければ 0。 */
+const phraseAt = (tokens: readonly Token[], at: number, phrases: Lexicon): number => {
+  const matched = phrases.map(wordsOf).find((words) => words.every((word, k) => tokens[at + k]?.surface.toLowerCase() === word));
+  return matched?.length ?? 0;
+};
+
+/** first から last まで、語のあいだが空白だけ。コードの印やリンクを挟めば別々の語。 */
+const joinedBySpace = (source: string, tokens: readonly Token[]): boolean =>
+  tokens.slice(1).every((token, k) => SPACE_ONLY.test(source.slice(tokens[k]?.span.end ?? token.span.start, token.span.start)));
+
+const opensSentence = (tokens: readonly Token[], at: number): boolean => !tokens.slice(0, at).some((token) => LETTER.test(token.surface));
+
+/** 文の途中の大文字の限定詞は、名前の一部（Plan A users）。 */
+const isNamePart = (tokens: readonly Token[], at: number): boolean => UPPER_START.test(tokens[at]?.surface ?? "") && !opensSentence(tokens, at);
+
+const isModifier = (token: Token): boolean => token.pos === "ADJ" || token.pos === "ADV" || (token.pos === "VERB" && isParticiple(token));
+
+/** 限定詞の後ろの修飾語。数の形容詞（a few days）が挟まれば、単数の限定詞でも複数を数えるので undefined。 */
+const modifiersAfter = (tokens: readonly Token[], from: number, count: ReadonlySet<string>): readonly Token[] | undefined => {
+  const end = tokens.findIndex((token, index) => index >= from && !isModifier(token));
+  const modifiers = tokens.slice(from, end === -1 ? tokens.length : end);
+  return modifiers.some((token) => count.has(lower(token))) ? undefined : modifiers;
+};
+
+const isGuessed = (token: Token): boolean => token.features?.["Guess"] === "Yes";
+
+/** 単数と複数が同じ綴りの語、複数と付いても原形が同じ語（lens）、解析器が形から当てた語（stimuli）は、どちらの数とも決まらない。 */
+const hasOneNumber = (noun: Token, invariant: ReadonlySet<string>): boolean =>
+  !invariant.has(lower(noun)) && !isGuessed(noun) && !(isPlural(noun) && noun.lemma?.toLowerCase() === lower(noun));
+
+const isCommonNoun = (token: Token | undefined): token is Token => token?.pos === "NOUN" && !UPPER_START.test(token.surface);
+
+type Determiner = { readonly head: Token; readonly length: number; readonly plural: boolean };
+
+const determinerAt = (tokens: readonly Token[], at: number, lists: AgreementLists): Determiner | undefined => {
+  const head = tokens[at];
+  const plural = phraseAt(tokens, at, lists.plural);
+  const singular = phraseAt(tokens, at, lists.singular);
+  if (head === undefined || plural + singular === 0) return undefined;
+  return plural > 0 ? { head, length: plural, plural: true } : { head, length: singular, plural: false };
+};
+
+/**
+ * 冠詞と句でない限定詞（this / these）は代名詞にもなる。This results in a loss の results は動詞なので、
+ * 形容詞を挟んだ名詞（this new rules）だけを数える。
+ */
+const standsAlone = (determiner: Determiner): boolean => determiner.length === 1 && !isArticle(determiner.head);
+
+const readsAsDeterminer = (determiner: Determiner, modifiers: readonly Token[]): boolean =>
+  !standsAlone(determiner) || modifiers.some((token) => token.pos === "ADJ");
+
+const mayBeNoun = (token: Token): boolean => token.features?.["AlsoNoun"] === "Yes" || isGuessed(token);
+
+/**
+ * 名詞が動詞にも読め（works）、その前に名詞句の頭になれる語があれば、限定詞と名詞ではなく主語と動詞かもしれない。
+ * an individual works（individual は名詞にもなる）/ Those responsible report to the board（those は代名詞にもなる）。
+ * 後ろが is / has なら、名詞は動詞ではない（these key result is）。
+ */
+const mayBeVerb = (determiner: Determiner, modifiers: readonly Token[], noun: Token, next: Token | undefined, finite: ReadonlySet<string>): boolean =>
+  noun.features?.["AlsoVerb"] === "Yes" && !(next !== undefined && finite.has(lower(next))) && (standsAlone(determiner) || modifiers.some(mayBeNoun));
+
+const numberSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const determiner = determinerAt(tokens, at, lists);
+  if (determiner === undefined || isNamePart(tokens, at)) return undefined;
+  const modifiers = modifiersAfter(tokens, at + determiner.length, lists.count);
+  if (modifiers === undefined || !readsAsDeterminer(determiner, modifiers)) return undefined;
+  const nounAt = at + determiner.length + modifiers.length;
+  const noun = tokens[nounAt];
+  if (!isCommonNoun(noun) || !hasOneNumber(noun, lists.invariant) || isPlural(noun) === determiner.plural) return undefined;
+  if (mayBeVerb(determiner, modifiers, noun, tokens[nounAt + 1], lists.finite)) return undefined;
+  const span = tokens.slice(at, nounAt + 1);
+  if (!endsNounPhrase(tokens[nounAt + 1], lists.finite) || !joinedBySpace(source, span) || isPartOfLongerWord(source, determiner.head, noun)) return undefined;
+  return slipOf("number", source, determiner.head, noun);
+};
+
+const slipOf = (variant: Slip["variant"], source: string, first: Token, last: Token): Slip => ({
+  variant,
+  first,
+  last,
+  word: source.slice(first.span.start, last.span.end).replace(/\s+/gu, " "),
+});
+
+const isBaseVerb = (token: Token | undefined): boolean => token?.pos === "VERB" && token.features?.["VerbForm"] === undefined;
+
+/** 所有の語の直後の be（their is）か、助動詞 + 動詞の原形（Your can check）。名詞にもなる助動詞（your will）は動詞が続くときだけ。 */
+const possessiveSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const [possessive, verb] = [tokens[at], tokens[at + 1]];
+  if (possessive === undefined || verb === undefined || !lists.possessive.has(lower(possessive))) return undefined;
+  // 大文字だけの語は略語（Your AM = account manager）。
+  const verbal = LOWER.test(verb.surface) && (lists.finite.has(lower(verb)) || (verb.pos === "AUX" && isBaseVerb(tokens[at + 2])));
+  if (!verbal || !joinedBySpace(source, [possessive, verb]) || isPartOfLongerWord(source, possessive, verb)) return undefined;
+  return slipOf("possessive", source, possessive, verb);
+};
+
+/** ones of the most。前に限定詞・形容詞・代名詞があれば、ones は代名詞（the ones of the most use）。 */
+const misnumberedAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const span = tokens.slice(at, at + phraseAt(tokens, at, lists.misnumbered));
+  const [first, last, previous] = [span[0], span.at(-1), tokens[at - 1]];
+  if (first === undefined || last === undefined || (previous !== undefined && PREDICATE_TAIL.has(previous.pos))) return undefined;
+  return joinedBySpace(source, span) ? slipOf("number", source, first, last) : undefined;
+};
+
+export const agreementIn = (source: string, tokens: readonly Token[], lists: AgreementLists): Slip[] =>
+  tokens.flatMap((_, at) => {
+    const slip = numberSlipAt(source, tokens, at, lists) ?? possessiveSlipAt(source, tokens, at, lists) ?? misnumberedAt(source, tokens, at, lists);
+    return slip === undefined ? [] : [slip];
+  });
+
+const setOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
+
+const listsOf = (lexicons: Readonly<Record<string, Lexicon>>): AgreementLists => ({
+  singular: lexicons["singular-determiner"] ?? [],
+  plural: lexicons["plural-determiner"] ?? [],
+  invariant: setOf(lexicons["invariant-noun"]),
+  count: setOf(lexicons["count-adjective"]),
+  possessive: setOf(lexicons["dependent-possessive"]),
+  finite: setOf(lexicons["finite-auxiliary"]),
+  misnumbered: lexicons["misnumbered-phrase"] ?? [],
+});
+
+export const agreementSlip: Detector = (doc): Finding[] => {
+  const lists = listsOf(doc.lexicons);
+  return doc.sentences.flatMap((sentence) =>
+    agreementIn(doc.source, sentence.tokens ?? [], lists).map((slip): Finding => ({
+      rule: "agreement-slip",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { word: slip.word, offset: slip.first.span.start },
+      variant: slip.variant,
+    })),
+  );
+};

package/src/detectors/char-shape.ts

@@ -6,6 +6,9 @@ import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
+import { maskSpans } from "../mask.ts";
+import { quotedSpans } from "../quoted-span.ts";
+import { nameSpans } from "../team-names.ts";
 
 /**
  * 文字の並びを見る検出。漢字の連なりが住所か名前かだけは、形態素解析の固有名詞と数で決める。
@@ -13,8 +16,8 @@ import { parallelDotCount } from "./middle-dot.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりと、その文書全体の座標での範囲。 */
-type KanjiRun = { readonly text: string; readonly span: Span | undefined };
+/** 漢字の連なりと、その文書全体の座標での範囲。quoted は鉤括弧の中身がまるごとこの連なりであること。 */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean };
 
 const SPACE = /\s/gu;
 
@@ -22,14 +25,22 @@ const SPACE = /\s/gu;
  * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
  * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
  */
-const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined): KanjiRun[] => {
+/** 番地と、チームが並べた名前を空白で覆う。名前は読み手が 1 語と知っているので、前後は別の連なりになる。 */
+const maskedProse = (prose: string, profile: DocumentProfile | undefined, names: readonly string[]): string =>
+  maskSpans(maskAddresses(prose, profile), nameSpans(prose, names));
+
+/** 鉤括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
+const fillsQuote = (sentence: Sentence, start: number, end: number): boolean =>
+  quotedSpans(sentence.text).some((span) => span.start === start && span.end === end);
+
+const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names: readonly string[]): KanjiRun[] => {
   const prose = proseText(sentence);
   const printed = compacted(sentence.text, "char").offsets;
-  return [...maskAddresses(prose, profile).matchAll(KANJI_RUN)].map((match) => {
+  return [...maskedProse(prose, profile, names).matchAll(KANJI_RUN)].map((match) => {
     const before = prose.slice(0, match.index).replace(SPACE, "").length;
     const [start, last] = [printed[before], printed[before + match[0].length - 1]];
-    const span = start === undefined || last === undefined ? undefined : { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
-    return { text: match[0], span };
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false };
+    return { text: match[0], span: { start: sentence.span.start + start, end: sentence.span.start + last + 1 }, quoted: fillsQuote(sentence, start, last + 1) };
   });
 };
 
@@ -44,14 +55,15 @@ const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet
  * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
  */
 const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+  if (run.quoted) return "";
   if (tokens === undefined || run.span === undefined) return run.text;
   const counter = leadingCounter(tokens, run.span.start, run.text);
   const rest = counter === undefined ? run.span : { start: counter.span.end, end: run.span.end };
   return isPlaceName(tokens, rest, topUnits) ? "" : run.text.slice(counter?.surface.length ?? 0);
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>): string =>
-  runsOf(sentence, profile)
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>, names: readonly string[]): string =>
+  runsOf(sentence, profile, names)
     .map((run) => measuredRun(sentence.tokens, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
@@ -62,7 +74,7 @@ const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined,
 export const kanjiRun: Detector = (doc, options): Finding[] => {
   const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
   return doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits, doc.names ?? []) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",