chaffjs 0.10.0 → 0.11.0

package/src/detectors/signals.ts

@@ -1,6 +1,7 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { compacted, placeOf } from "./gram-place.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -91,13 +92,44 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   return counts;
 };
 
+/** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
+const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: ProseDocument["lengthUnit"]): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/**
+ * 語句が文の中で占める範囲に、動詞か助動詞があるか。範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
+ */
+const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
+  if (sentence.tokens === undefined) return true;
+  const place = placeOf(compacted(sentence.text, unit), gram);
+  if (place === undefined) return true;
+  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
+  const tokens = sentence.tokens;
+  return tokens.some((token, index) => PREDICATE_POS.has(token.pos) && token.span.start < end && start < token.span.end && !modifiesNoun(tokens, index, unit));
+};
+
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   if (wordsOf(doc) < FLOOR[doc.lengthUnit]) return [];
+  const sentenceWith = (gram: string): Sentence | undefined => doc.sentences.find((sentence) => gramText(sentence, doc.lengthUnit).includes(gram));
   const worst = [...gramsOf(doc).entries()]
-    .filter(([gram]) => isPhrasing(gram, doc.lengthUnit))
-    .reduce<{ gram: string; count: number }>((best, [gram, count]) => (count > best.count ? { gram, count } : best), { gram: "", count: 0 });
-  if (worst.count <= options.limit) return [];
-  const at = doc.sentences.find((sentence) => sentence.text.includes(worst.gram));
+    .filter(([gram, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
+    .sort(([, left], [, right]) => right - left)
+    .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
+    .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
+  if (worst === undefined) return [];
+  const at = worst.at;
   return [
     {
       rule: "ngram-repetition",
@@ -113,8 +145,57 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
 /**
  * 略語が初出で展開されているか。「CI」だけでは、読む人によって指すものが違う。
  * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
+ *
+ * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
+ */
+const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,6})${EDGE_AFTER}`, "gu");
+
+/**
+ * 大文字で書かれていても略語ではないもの。
+ *
+ * 大文字だけの語が 3 つ以上、空白と引用符だけを挟んで続くのは強調（免責の定型文など）。
+ * 強調は読点や括弧をまたいで続くので（THE AUTHOR, THE COMPANY (IF ANY)）、そういう続きを含む
+ * 「大文字以外の文字を含まない一続き」を丸ごと強調と見なす。小文字の語が挟まれば切れるので、
+ * 「SRE, SLO, MTTR」のような略語の並びは残る。引用符に包まれた大文字の句（“AS IS”）も強調。
  */
-const ACRONYM = /\b[A-Z]{2,6}\b/gu;
+const CAPS_WORD = String.raw`[A-Z]+(?:&[A-Z]+)*`;
+const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:[\s"“”'‘’]+${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+const UNCASED_STRETCH = /(?:[A-Z]|\P{L})+/gu;
+const QUOTED_CAPS = new RegExp(String.raw`["“'‘]${CAPS_WORD}(?:\s+${CAPS_WORD})+["”'’]`, "gu");
+
+/** RFC 2119 の要件語。定義された普通の語で、1 語でも強調でも現れる。 */
+const REQUIREMENT_WORD = new RegExp(
+  String.raw`${EDGE_BEFORE}(?:(?:MUST|SHALL|SHOULD)(?:\s+NOT)?|NOT\s+RECOMMENDED|REQUIRED|RECOMMENDED|MAY|OPTIONAL)${EDGE_AFTER}`,
+  "gu",
+);
+
+/** - か . で繋がり、数字を含む識別子（AC-2、MS.TEAMS.1.1v1）。大文字の部品は略語ではない。 */
+const IDENTIFIER = /(?<![A-Za-z0-9_&.-])[A-Z0-9][A-Za-z0-9]*(?:[.-][A-Z0-9][A-Za-z0-9]*)+/gu;
+
+/** Creative Commons のライセンス名。CC と BY は 1 つの名前の部品。 */
+const LICENCE = new RegExp(String.raw`${EDGE_BEFORE}CC BY(?:-(?:SA|NC|ND))*${EDGE_AFTER}`, "gu");
+
+type Span = { readonly start: number; readonly end: number };
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const spansOf = (text: string): Span[] => [
+  ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
+  ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
+  ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
+];
+
+type AcronymHit = { readonly word: string; readonly hit: Hit };
+
+const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+  doc.sentences.flatMap((sentence) => {
+    const excluded = spansOf(sentence.text);
+    return [...sentence.text.matchAll(ACRONYM)]
+      .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
+      .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
+  });
 
 /** 読み手が説明なしで通じると見なしてよい語。展開すると逆に読みにくい。 */
 const COMMON = new Set([
@@ -146,34 +227,100 @@ const COMMON = new Set([
   "XML",
   "TODO",
   "NOTE",
+  // 通信と符号化。技術文書でなくても説明なしで通じる。
+  "DNS",
+  "IP",
+  "TCP",
+  "UDP",
+  "SSH",
+  "SSL",
+  "TLS",
+  "VPN",
+  "LAN",
+  "UTF",
+  "ASCII",
+  // 機器・形式・単位。
+  "PC",
+  "IT",
+  "SDK",
+  "IDE",
+  "PNG",
+  "JPEG",
+  "GIF",
+  "SVG",
+  "QR",
+  "GPS",
+  "SNS",
+  "TV",
+  "KB",
+  "MB",
+  "GB",
+  "TB",
+  // 役職と国・地域。
+  "CEO",
+  "CTO",
+  "CFO",
+  "US",
+  "UK",
+  "EU",
+  "UN",
+  "DNA",
 ]);
 
 /**
  * 展開は略語の**すぐ隣**にあるときだけ認める。
  * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
  *
- * 認めるのは 2 つの形。どちらも実際によく書かれる。
+ * 認めるのは 3 つの形。どれも実際によく書かれる。
  *   CI（継続的インテグレーション）   略語のあとに括弧
  *   Continuous Integration (CI)      括弧の中が略語
+ *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
+ */
+const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
+const OPENS = new RegExp(String.raw`^${WRAP}[(（]`, "u");
+const CLOSES = new RegExp(String.raw`^${WRAP}[)）]`, "u");
+const OPENED = new RegExp(String.raw`[(（]${WRAP}$`, "u");
+const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
+const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
+
+/** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
+const NEAR = 3;
+
+/**
+ * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
+ * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
-const OPENS = /^\s*[(（]/u;
-const CLOSES = /^\s*[)）]/u;
-const OPENED = /[(（]\s*$/u;
+const spellsOut = (before: string, acronym: string): boolean => {
+  const letters = acronym.replaceAll("&", "");
+  const words = before
+    .replace(SQUARE_OPENED, "")
+    .trim()
+    .split(/\s+/u)
+    .slice(-letters.length * 2);
+  const initials = words.filter((word) => /^[A-Z]/u.test(word)).map((word) => word.charAt(0));
+  return initials.join("").endsWith(letters);
+};
 
-const isExpanded = (body: string, acronym: string): boolean => {
-  const at = body.indexOf(acronym);
-  if (at === -1) return false;
-  const after = body.slice(at + acronym.length, at + acronym.length + 3);
-  const before = body.slice(Math.max(0, at - 3), at);
-  return OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after));
+const isExpandedAt = (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;
+  return SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym);
 };
 
+/**
+ * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
+ * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
+ */
+const isExpanded = (body: string, acronym: string): boolean =>
+  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => isExpandedAt(body, acronym, match.index));
+
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   const seen = new Map<string, Hit>();
-  findIn(doc, ACRONYM).forEach((hit) => {
-    const text = /^[A-Z]{2,6}/u.exec(doc.source.slice(hit.offset, hit.offset + 6))?.[0] ?? "";
-    if (text.length > 0 && !COMMON.has(text) && !seen.has(text)) seen.set(text, hit);
+  acronymsOf(doc).forEach(({ word, hit }) => {
+    if (!COMMON.has(word) && !seen.has(word)) seen.set(word, hit);
   });
   const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym));
   if (bare.length < options.limit) return [];
@@ -193,9 +340,29 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
  */
 const CONCRETE = /\d|`|https?:\/\//u;
 
+/**
+ * 見出しのない導入部は、書き出しで呼ぶ。文書の言葉なので、message がどの言語でも混ざらない。
+ * 決まった呼び名（「この節」）を置くと、英語の文書の message に日本語が入る。
+ */
+const OPENING = { word: 4, char: 12 };
+
+const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUnit"]): string => {
+  const text = sentence === undefined ? "" : proseText(sentence);
+  const pieces = unit === "word" ? text.split(" ") : Array.from(text);
+  const joiner = unit === "word" ? " " : "";
+  return pieces.length <= OPENING[unit] ? pieces.join(joiner) : `${pieces.slice(0, OPENING[unit]).join(joiner)}…`;
+};
+
+/**
+ * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
+ * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。品詞が無ければ、数字だけを見る。
+ */
+const hasNumeral = (section: Section): boolean =>
+  section.sentences.some((sentence) => (sentence.tokens ?? []).some((token) => token.features?.["NumType"] === "Card"));
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const sections = doc.sections.filter((section) => section.sentences.length >= 3);
-  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)));
+  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeral(section));
   if (empty.length < options.limit) return [];
   return empty.map((section) => ({
     rule: "concrete-evidence-density",
@@ -204,7 +371,7 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
     column: 0,
     quote: section.heading.length > 0 ? section.heading : (section.sentences[0]?.text.trim() ?? ""),
     values: {
-      word: section.heading.length > 0 ? section.heading : "この節",
+      word: section.heading.length > 0 ? section.heading : openingOf(section.sentences[0], doc.lengthUnit),
       count: empty.length,
       total: sections.length,
       limit: options.limit,

package/src/document.ts

@@ -5,8 +5,10 @@ import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
-import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
+import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
+import { pageFurniture, textOutline } from "./page-furniture.ts";
+import { tokenizedLexicons } from "./lexicon-tokens.ts";
 import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
@@ -263,12 +265,20 @@ export const buildDocument = (
   const root = parse(source);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
-  const blocks = collectMasks(root, source);
+  // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
+  const blocks = [...collectMasks(root, source), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
   const masked = [...blocks, ...emphasisSpans(root, source)];
   const prose = maskSpans(source, masked);
   const paragraphSpans = spansOfType(root, "paragraph");
   const listItems = spansOfType(root, "listItem");
   const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  const lexicons = {
+    ...adapter.lexicons,
+    "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
+    // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
+    "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
+  };
+  const tagged = sentences.some((sentence) => sentence.tokens !== undefined);
   const patterns = adapter.structure;
   // null は「作ったが構造を読めない言語だった」、undefined は「まだ作っていない」。
   const tree: { value: StructureNode | null | undefined } = { value: undefined };
@@ -283,19 +293,25 @@ export const buildDocument = (
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: {
-      ...adapter.lexicons,
-      "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
-      // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
-      "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
-    },
+    lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {
       tree.value ??=
         patterns === undefined
           ? null
-          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE, profile }, patterns);
+          : buildTree(
+              {
+                path,
+                source,
+                language: adapter.id,
+                // テキストの文書は、ページの飾りを覆って読む。フッターの「Section 9」を木の節にしない。
+                outline: isMarkdownPath(path) ? outlineOf(root, source) : textOutline(source),
+                markdown: isMarkdownPath(path),
+                profile,
+              },
+              patterns,
+            );
       return tree.value ?? undefined;
     },
     profile,

package/src/lexicon-tokens.ts

@@ -0,0 +1,28 @@
+import type { LanguageAdapter, Lexicon, LexiconEntry } from "./plugin.ts";
+
+/** adapter の語彙表は adapter ごとに一度だけ分ける。チームの語彙表は文書ごとに作られるので、この表に残らない。 */
+const split = new WeakMap<LanguageAdapter, WeakMap<Lexicon, Lexicon>>();
+
+const splitBy = (adapter: LanguageAdapter): WeakMap<Lexicon, Lexicon> => {
+  const known = split.get(adapter) ?? new WeakMap<Lexicon, Lexicon>();
+  split.set(adapter, known);
+  return known;
+};
+
+const tokenized = (entry: LexiconEntry, adapter: LanguageAdapter): LexiconEntry => {
+  const tokens = adapter.segment(entry.pattern).sentences.flatMap((sentence) => sentence.tokens ?? []);
+  return tokens.length === 0 ? entry : { ...entry, tokens };
+};
+
+const withTokens = (lexicon: Lexicon, adapter: LanguageAdapter): Lexicon => {
+  const cache = splitBy(adapter);
+  const known = cache.get(lexicon);
+  if (known !== undefined) return known;
+  const made = lexicon.map((entry) => tokenized(entry, adapter));
+  cache.set(lexicon, made);
+  return made;
+};
+
+/** 語彙表の語を、文と同じ解析器で語に分けておく。語彙表の検査が原形で照らせるように。品詞を読んでいない文書には何もしない。 */
+export const tokenizedLexicons = (lexicons: Readonly<Record<string, Lexicon>>, adapter: LanguageAdapter): Readonly<Record<string, Lexicon>> =>
+  Object.fromEntries(Object.entries(lexicons).map(([name, lexicon]) => [name, withTokens(lexicon, adapter)]));

package/src/page-furniture.ts

@@ -0,0 +1,45 @@
+import type { Span } from "./plugin.ts";
+import { NO_OUTLINE, type Outline } from "./structure/build.ts";
+
+/** 改ページから、飾りの行を探しにいく行数。飾りと改ページのあいだには空行が数行入る。 */
+const REACH = 3;
+
+type Line = { readonly start: number; readonly end: number; readonly text: string };
+
+const linesOf = (source: string): Line[] => {
+  const scan = { start: 0 };
+  return source.split("\n").map((text) => {
+    const line = { start: scan.start, end: scan.start + text.length, text };
+    scan.start = line.end + 1;
+    return line;
+  });
+};
+
+const isBlank = (line: Line | undefined): boolean => line !== undefined && line.text.trim() === "";
+
+/** 改ページだけの行。行の途中の \f は本文の一部（写し間違い）で、ページの区切りではない。 */
+const PAGE_BREAK = /^[ \t]*\f[ \t\r]*$/u;
+
+/** index から step の向きに、空行を飛ばして最初の空でない行。REACH 行を越えたら探さない。 */
+const nearestText = (lines: readonly Line[], index: number, step: number): Line | undefined => {
+  const candidates = Array.from({ length: REACH }, (_, offset) => lines[index + step * (offset + 1)]);
+  const skipped = candidates.findIndex((line) => !isBlank(line));
+  return skipped === -1 ? undefined : candidates[skipped];
+};
+
+/**
+ * 紙の版を写したテキスト（RFC など）の、ページのヘッダーとフッター。改ページ（\f）の直前と直後の、空でない 1 行ずつ。
+ * ページごとに同じ行が出るので、本文として読むと「同じ言い回しの繰り返し」や長い文になる。
+ */
+export const pageFurniture = (source: string): Span[] => {
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => {
+    if (!PAGE_BREAK.test(line.text)) return [];
+    return [nearestText(lines, index, -1), line, nearestText(lines, index, 1)].flatMap((found) =>
+      found === undefined ? [] : [{ start: found.start, end: found.end }],
+    );
+  });
+};
+
+/** テキストの文書の外形。見出しもコードも無く、ページの飾りだけを覆う。木を作る入口はどれもこれを使う。 */
+export const textOutline = (source: string): Outline => ({ ...NO_OUTLINE, opaque: pageFurniture(source) });

package/src/plugin.ts

@@ -36,7 +36,13 @@ export type LengthUnit = "char" | "word";
  * `instead_of` は「同じことを言う別の書きかた」。文体の一貫性を見る rule が使う。
  * 2 つの書きかたのどちらが正しいかは決めず、**1 つの文書で混ざっていないか**だけを見る。
  */
-export type LexiconEntry = { readonly pattern: string; readonly weight?: number | undefined; readonly instead_of?: string | undefined };
+export type LexiconEntry = {
+  readonly pattern: string;
+  readonly weight?: number | undefined;
+  readonly instead_of?: string | undefined;
+  /** pattern を adapter が語に分けたもの。品詞が読めるときだけ core が入れる。語彙表を書く側は書かない。 */
+  readonly tokens?: readonly Token[] | undefined;
+};
 
 export type Lexicon = readonly LexiconEntry[];
 
@@ -343,6 +349,8 @@ export type RuleDefinition = {
   readonly where: string | undefined;
   /** adapter に要る capability。"pos" / "lemma"。満たさなければ動かさない。spec §16。 */
   readonly requires: readonly string[];
+  /** 使えるなら用意してほしい capability（"pos"）。requires と違い、満たせなくても動かす（品詞が無ければ文字だけで見る）。 */
+  readonly uses: readonly string[];
   /** 複合シグナル。ここに並べた rule のうち何本が出たかを見る。spec §20.2。 */
   readonly from: readonly string[];
   /** 動かす言語。未指定は全言語。「ですます調」のように言語に固有の rule が使う。 */

package/src/render/compact.ts

@@ -1,10 +1,19 @@
 import type { RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 
 /** 「1 finding」「2 findings」。 */
 const counted = (count: number, noun: string): string => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 
+/**
+ * 最後の集計の行は、画面のほかの部分と同じく文書の言語で出す。行ごとの重さ（warning / error）は、grep や別の道具が読むので英語のまま。
+ */
+const TALLY: Texts<{ readonly findings: (n: number) => string; readonly notRun: (n: number) => string; readonly separator: string }> = {
+  ja: { findings: (n) => `指摘 ${String(n)} 件`, notRun: (n) => `動いていない rule ${String(n)} 件`, separator: "、" },
+  en: { findings: (n) => counted(n, "finding"), notRun: (n) => `${counted(n, "rule")} not run`, separator: ", " },
+};
+
 /** エンジニア向け。1 件 2 行。 */
 export const renderCompact = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
@@ -14,8 +23,9 @@ export const renderCompact = (header: string, result: RunResult, rules: readonly
     const at = `${finding.line}:${finding.column}`.padEnd(8);
     return [`  ${at}${finding.severity.padEnd(8)}${messageOf(rule, finding, language)}`, `          ${" ".repeat(8)}${finding.rule}`];
   });
-  const tail = [counted(result.findings.length, "finding"), result.skipped.length > 0 ? `${counted(result.skipped.length, "rule")} not run` : undefined].filter(
+  const text = TALLY[uiLanguageOf(language)];
+  const tail = [text.findings(result.findings.length), result.skipped.length > 0 ? text.notRun(result.skipped.length) : undefined].filter(
     (part) => part !== undefined,
   );
-  return ["", header, "", ...lines, "", tail.join(", "), ""].join("\n");
+  return ["", header, "", ...lines, "", tail.join(text.separator), ""].join("\n");
 };

package/src/rule-load.ts

@@ -102,6 +102,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
     requires: stringList(raw["requires"]) ?? [],
+    uses: stringList(raw["uses"]) ?? [],
     from: stringList(raw["from"]) ?? [],
     languages: stringList(raw["languages"]),
     use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],

package/src/run.ts

@@ -6,6 +6,8 @@ import { REASONS, type Reasons } from "./reasons.ts";
 import { joinWords } from "./detectors/word-list.ts";
 import { unreadStructure, type Unread } from "./structure/unread.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
+import { maskSpans } from "./mask.ts";
+import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
@@ -51,8 +53,9 @@ const treeProblem = (doc: ProseDocument): string | undefined => {
   return unread === undefined ? undefined : reasonsFor(doc).unreadStructure(unread.clauses, unread.units);
 };
 
-/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はそのまま（.txt の字下げはコードではない）。 */
-const textTheTreeRead = (doc: ProseDocument): string => (isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : doc.source);
+/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はページの飾りだけを覆ったもの（.txt の字下げはコードではない）。 */
+const textTheTreeRead = (doc: ProseDocument): string =>
+  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source).opaque);
 
 const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
 
@@ -104,7 +107,7 @@ export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, e
   pos: forGenre(rules, genre)
     .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental) !== "off")
     .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
-    .some((rule) => rule.requires.includes("pos") || rule.requires.includes("lemma")),
+    .some((rule) => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma")),
 });
 
 const place = (starts: readonly number[], finding: Finding): Finding => {

package/src/sentence-shape.ts

@@ -37,4 +37,20 @@ const beforeTrailing = (sentence: Sentence): readonly Token[] => {
   return kept.length === 0 ? tokens : kept;
 };
 
+/** 閉じた引用。文がこれで終われば、文末は引用した文のもので、書き手の文末ではない。 */
+const CLOSING_QUOTES = ["」", "』", "\u201d"];
+
+/**
+ * 文末の語: 句読点・終助詞・添えた括弧を除いた後ろから、助動詞の連なりと、その前の述語一つ。
+ * 「測定しません」なら「し・ませ・ん」、「十分でしたか」なら「十分・でし・た」。文の途中の引用（「ご覧ください」という）は入らない。
+ * 引用で終わる文（画面には「確認します。」。）は、書き手の文末が無いので空。
+ */
+export const endingTokens = (sentence: Sentence): Token[] => {
+  const reversed = [...beforeTrailing(sentence)].reverse();
+  const last = reversed.findIndex((token) => !SKIP.has(token.pos));
+  if (last === -1 || reversed.slice(0, last).some((token) => CLOSING_QUOTES.some((quote) => token.surface.includes(quote)))) return [];
+  const head = reversed.findIndex((token, index) => index >= last && token.pos !== "AUX");
+  return reversed.slice(last, head === -1 ? reversed.length : head + 1).reverse();
+};
+
 export const lastContent = (sentence: Sentence): Token | undefined => [...beforeTrailing(sentence)].reverse().find((token) => !SKIP.has(token.pos));

package/src/structure/bare-numbers.ts

@@ -0,0 +1,78 @@
+import type { Line } from "./runs.ts";
+
+/** 単位を書かない数。単位は表の列の見出しにあるか、無い。木の数量は必ず単位を持つので、空の単位とは重ならない。 */
+export const NO_UNIT = "";
+
+export type BareNumber = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: typeof NO_UNIT };
+
+/**
+ * 表の升に数だけを書いたもの（1,205、12.5、-50、▲50、**1,205**）。前の印と強調は数に入れない。
+ * 0 で始まる番号（007）、区切りの崩れた 1,20、括弧の (50)、注の付いた 1,205a は数にしない。
+ */
+const BARE_NUMBER = /^(?:[1-9]\d{0,2}(?:,\d{3})+|[1-9]\d*|0)(?:\.\d+)?$/u;
+
+/** 数の前の空白、強調、負の印（-、▲）と、数の後ろの強調と空白。 */
+const BEFORE_NUMBER = /^[ \t]*[*_]*(?:[-−▲△][ \t]?)?/u;
+const AFTER_NUMBER = /^[*_]*\s*$/u;
+const DIGITS = /^[\d,.]*/u;
+
+/** 表の列の区切り。\| は列の中に書いた | なので数えない。 */
+export const CELL_SEPARATOR = /(?<!\\)\|/gu;
+
+type CellSpan = { readonly start: number; readonly end: number };
+
+const cellsOf = (source: string, line: Line): CellSpan[] => {
+  const text = source.slice(line.start, line.end);
+  const bounds = [-1, ...[...text.matchAll(CELL_SEPARATOR)].map((match) => match.index), text.length];
+  return bounds.slice(1).map((end, index) => ({ start: line.start + (bounds[index] ?? 0) + 1, end: line.start + end }));
+};
+
+type InColumn = BareNumber & { readonly column: number; readonly digits: string };
+
+const bareNumberIn = (source: string, cell: CellSpan, column: number): InColumn[] => {
+  const text = source.slice(cell.start, cell.end);
+  const before = BEFORE_NUMBER.exec(text)?.[0] ?? "";
+  const rest = text.slice(before.length);
+  const digits = DIGITS.exec(rest)?.[0] ?? "";
+  if (!BARE_NUMBER.test(digits) || !AFTER_NUMBER.test(rest.slice(digits.length))) return [];
+  const offset = cell.start + before.length;
+  return [{ offset, end: offset + digits.length, value: Number(digits.replace(/,/gu, "")), unit: NO_UNIT, column, digits }];
+};
+
+/** 表の見出し。最初の行の上の区切り行（|---|）の、さらに上の行。 */
+const headerAbove = (source: string, firstRow: Line | undefined): string => {
+  if (firstRow === undefined || firstRow.start < 2) return "";
+  const ruleStart = source.lastIndexOf("\n", firstRow.start - 2) + 1;
+  if (ruleStart < 2) return "";
+  return source.slice(source.lastIndexOf("\n", ruleStart - 2) + 1, ruleStart - 1);
+};
+
+/** 見出しに % のある列は率。 */
+const PERCENT = /[%％]/u;
+
+/** 同じ桁数で 4 桁以上の、区切りの無い整数だけの列は、年か番号（2024、1041）。 */
+const YEAR_OR_CODE = /^\d{4,}$/u;
+
+const isYearsOrCodes = (numbers: readonly InColumn[]): boolean =>
+  numbers.every((number) => YEAR_OR_CODE.test(number.digits) && number.digits.length === numbers[0]?.digits.length);
+
+/** 足してよい列か。見出しが率を言う列と、年や番号の列は足さない。 */
+const isAmountColumn = (header: string, numbers: readonly InColumn[], column: number): boolean =>
+  !PERCENT.test(header.split(CELL_SEPARATOR)[column] ?? "") && !isYearsOrCodes(numbers);
+
+/** 表の行の、数だけを書いた升。箇条書きの行は読まない。 */
+export const bareNumbersIn = (source: string, lines: readonly Line[]): BareNumber[] => {
+  const rows = lines.filter((line) => line.kind === "table");
+  const found = rows.flatMap((line) => cellsOf(source, line).flatMap((cell, column) => bareNumberIn(source, cell, column)));
+  const header = headerAbove(source, rows[0]);
+  const amountColumns = new Set(
+    [...new Set(found.map((number) => number.column))].filter((column) =>
+      isAmountColumn(
+        header,
+        found.filter((number) => number.column === column),
+        column,
+      ),
+    ),
+  );
+  return found.filter((number) => amountColumns.has(number.column)).map(({ offset, end, value, unit }) => ({ offset, end, value, unit }));
+};