chaffjs 0.10.0 → 0.12.0

package/src/detectors/superlative-scope.ts

@@ -0,0 +1,66 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/**
+ * 最上級が範囲を持っているか。「日本で最も」「国内最大」"the best in the world" は、何の中で最もなのかを言っている。
+ * 範囲を示す語は言語で違い、置く側も違う（日本語は最上級の前、英語は後ろ）。どちらの語も言語パッケージの語彙表が持つ。
+ */
+export type ScopeMarkers = {
+  /** 最上級の直前に置く語（で）。その前に固有名詞か地名が要る。 */
+  readonly before: Lexicon;
+  /** 最上級の名詞句の直後に置く語（in・of）。その後ろに名詞句が要る。 */
+  readonly after: Lexicon;
+};
+
+/** 語彙表の position で分ける。position の無い語は、どちら側の語か分からないので使わない。 */
+export const scopeMarkersOf = (lexicon: Lexicon): ScopeMarkers => ({
+  before: lexicon.filter((entry) => entry.position === "before"),
+  after: lexicon.filter((entry) => entry.position === "after"),
+});
+
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** 名詞句の始まり。the world・Chicago・our products・the three・all。 */
+const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+
+/** 名詞の前に来る修飾（most skilled・widely used・stuffed）。名詞が出た後は名詞の連なりだけが続く。 */
+const PREMODIFIER = new Set(["ADJ", "ADV", "VERB", "NOUN", "PROPN", "NUM"]);
+const NOUN_RUN = new Set(["NOUN", "PROPN", "NUM"]);
+
+/** 範囲の前に置ける語。修飾だけで終わった句（the best is in …）は範囲ではなく述語。 */
+const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
+
+const isMarker = (token: Token | undefined, markers: Lexicon): boolean =>
+  token !== undefined && markers.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
+
+const isNamed = (token: Token | undefined): boolean => token !== undefined && (token.pos === "PROPN" || token.features?.["NameType"] !== undefined);
+
+/** 空白も助詞も挟まずに名詞が付いた最上級（国内最大・業界最速・世界唯一）。前の名詞が範囲。 */
+const compound = (tokens: readonly Token[], range: TokenRange): boolean => {
+  const before = tokens[range.start - 1];
+  const first = tokens[range.start];
+  return before !== undefined && first !== undefined && NOMINAL.has(before.pos) && before.span.end === first.span.start;
+};
+
+/** 名前 + 範囲の語 + 最上級（日本で最も・トヨタで最も・東京都で最大）。「費用で最大の効果」の「費用」は名前ではないので範囲にしない。 */
+const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
+  isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
+
+/** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
+const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
+  const token = tokens[at];
+  if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
+  return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));
+};
+
+/** 最上級 + 名詞句 + 範囲の語 + 名詞句（the best pizza in Chicago・the most famous of the sculptures）。 */
+const phraseAfter = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean => {
+  const at = phraseEnd(tokens, range.end);
+  const last = tokens[at - 1];
+  const endsPhrase = at === range.end || (last !== undefined && PHRASE_END.has(last.pos));
+  const opens = tokens[at + 1];
+  return endsPhrase && isMarker(tokens[at], markers) && opens !== undefined && PHRASE_START.has(opens.pos);
+};
+
+export const scoped = (tokens: readonly Token[], range: TokenRange, markers: ScopeMarkers): boolean =>
+  compound(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);

package/src/document.ts

@@ -4,14 +4,21 @@ import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
 import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
+import { hasTitle } from "./heading-title.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 { inPageAnchors, isInPageNavigation, isNavigationList, type InPageAnchors } from "./in-page-nav.ts";
 import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
   readonly type: string;
+  readonly url?: string | undefined;
+  readonly value?: string | undefined;
+  readonly identifier?: string | undefined;
   readonly position?: { readonly start: Place; readonly end: Place } | undefined;
   readonly children?: readonly Node[] | undefined;
 };
@@ -91,14 +98,14 @@ const matchSpans = (source: string, pattern: RegExp): Span[] =>
 
 const directiveSpans = (source: string): Span[] => [...matchSpans(source, DIRECTIVE), ...matchSpans(source, BARE_URL)];
 
-const collectMasks = (root: Node, source: string): Span[] => {
+const collectMasks = (root: Node, source: string, anchors: InPageAnchors): Span[] => {
   const spans: Span[] = [...directiveSpans(source)];
   walk(root, (node) => {
     if (node.type === "link" || node.type === "linkReference") {
       spans.push(...linkChrome(node));
       return;
     }
-    if (!NOT_PROSE.has(node.type) && node.type !== "heading") return;
+    if (!NOT_PROSE.has(node.type) && node.type !== "heading" && !isInPageNavigation(node, anchors)) return;
     const span = spanOf(node);
     if (span !== undefined) spans.push(span);
   });
@@ -134,7 +141,8 @@ const headingsOf = (root: Node, source: string): Heading[] => {
     if (span === undefined) return;
     // ATX（行頭が #）なら閉じの # も外す。setext の見出しの末尾の # は言葉なので残す。
     const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
-    found.push({ depth, text: read(textOf(node, source)), start: span.start, end: span.end });
+    const text = read(textOf(node, source));
+    if (hasTitle(text)) found.push({ depth, text, start: span.start, end: span.end });
   });
   return found;
 };
@@ -160,10 +168,10 @@ const strongSpans = (root: Node, masked: readonly Span[]): Span[] => {
 
 const within = (span: Span, from: number, to: number): boolean => span.start >= from && span.start < to;
 
-const spansOfType = (root: Node, type: string): Span[] => {
+const spansOfType = (root: Node, type: string, keep: (node: Node) => boolean = () => true): Span[] => {
   const found: Span[] = [];
   walk(root, (node) => {
-    if (node.type !== type) return;
+    if (node.type !== type || !keep(node)) return;
     const span = spanOf(node);
     if (span !== undefined) found.push(span);
   });
@@ -216,11 +224,11 @@ const paragraphsOf = (spans: readonly Span[], sentences: readonly Sentence[], li
     .filter((span) => !listSpans.some((list) => span.start >= list.start && span.start < list.end))
     .map((span) => ({ span, sentences: sentences.filter((sentence) => within(sentence.span, span.start, span.end)) }));
 
-/** 箇条書きは list ノードの直下の項目を数える。入れ子の項目は内側の list のものとして数える。 */
-const listsOf = (root: Node, source: string): BulletList[] => {
+/** 箇条書きは list ノードの直下の項目を数える。入れ子の項目は内側の list のものとして数える。目次のような案内だけの箇条書きは数えない。 */
+const listsOf = (root: Node, source: string, anchors: InPageAnchors): BulletList[] => {
   const found: BulletList[] = [];
   walk(root, (node) => {
-    if (node.type !== "list") return;
+    if (node.type !== "list" || isNavigationList(node, anchors)) return;
     const span = spanOf(node);
     if (span === undefined) return;
     const items = (node.children ?? []).flatMap((child) => {
@@ -261,14 +269,24 @@ export const buildDocument = (
   profile: DocumentProfile | undefined = undefined,
 ): ProseDocument => {
   const root = parse(source);
+  const anchors = inPageAnchors(root);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
-  const blocks = collectMasks(root, source);
+  // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
+  const blocks = [...collectMasks(root, source, anchors), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
   const masked = [...blocks, ...emphasisSpans(root, source)];
   const prose = maskSpans(source, masked);
-  const paragraphSpans = spansOfType(root, "paragraph");
+  // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
+  const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   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 };
@@ -282,20 +300,26 @@ export const buildDocument = (
     sentences,
     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 })),
-    },
+    lists: listsOf(root, source, anchors),
+    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/eval.ts

@@ -1,6 +1,7 @@
 import { DETECTORS } from "./detectors/index.ts";
 import { charLength } from "./measure.ts";
 import type { ProseDocument, RuleDefinition } from "./plugin.ts";
+import { missingList } from "./declared-lists.ts";
 
 /**
  * 閾値の較正。
@@ -48,7 +49,6 @@ const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: nu
   if (detector === undefined) return { limit, findings: 0, documents: 0, per10k: 0 };
   const perDoc = docs.map((doc) => {
     const lexicon = rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list];
-    if (rule.word_list !== undefined && lexicon === undefined) return 0;
     return detector(doc, { limit, lexicon, where: rule.where }).length;
   });
   const findings = perDoc.reduce((sum, count) => sum + count, 0);
@@ -82,6 +82,7 @@ const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre:
   if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
   if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
   if (rule.from.length > 0) return false;
+  if (docs.some((doc) => missingList(rule, doc.lexicons) !== undefined)) return false;
   return rule.requires.every((need) => meets(need, docs));
 };
 

package/src/heading-title.ts

@@ -0,0 +1,8 @@
+/** 文字か数字。記号・空白・絵文字だけの並びには、読者が指せる題が無い。 */
+const TITLE_CHARACTER = /[\p{L}\p{N}]/u;
+
+/**
+ * 見出しに題があるか。`###` だけの行や `## ---` は、変換で残った空の `<h3>` のような区切りで、
+ * 本文の始まりでも読者が辿れる節でもない。題の無い見出しは見出しとして数えず、前後の本文を 1 つの節として読む。
+ */
+export const hasTitle = (headingWords: string): boolean => TITLE_CHARACTER.test(headingWords);

package/src/in-page-nav.ts

@@ -0,0 +1,67 @@
+/** mdast の節のうち、ページ内の案内かどうかの判定に要る部分だけ。 */
+export type NavNode = {
+  readonly type: string;
+  readonly url?: string | undefined;
+  readonly value?: string | undefined;
+  readonly identifier?: string | undefined;
+  readonly children?: readonly NavNode[] | undefined;
+};
+
+/** 参照形式のリンク（`[目次][toc]`）の名前のうち、定義（`[toc]: #目次`）が同じページの中を指すもの。 */
+export type InPageAnchors = ReadonlySet<string>;
+
+/** 文字か数字。これが 1 つでもあれば、書いた人の言葉がある。記号（▲ ↑ | ・）だけなら飾り。 */
+const WORD = /[\p{L}\p{N}]/u;
+
+const WRAPPERS = new Set(["strong", "emphasis", "delete"]);
+
+const pointsInPage = (url: string | undefined): boolean => (url ?? "").startsWith("#");
+
+const collectAnchors = (node: NavNode, found: Set<string>): void => {
+  if (node.type === "definition" && node.identifier !== undefined && pointsInPage(node.url)) found.add(node.identifier);
+  (node.children ?? []).forEach((child) => collectAnchors(child, found));
+};
+
+export const inPageAnchors = (root: NavNode): InPageAnchors => {
+  const found = new Set<string>();
+  collectAnchors(root, found);
+  return found;
+};
+
+const isInPageLink = (node: NavNode, anchors: InPageAnchors): boolean =>
+  (node.type === "link" && pointsInPage(node.url)) || (node.type === "linkReference" && anchors.has(node.identifier ?? ""));
+
+const isNavigationPart = (node: NavNode, anchors: InPageAnchors): boolean => {
+  if (isInPageLink(node, anchors) || node.type === "break") return true;
+  if (node.type === "text") return !WORD.test(node.value ?? "");
+  return WRAPPERS.has(node.type) && (node.children ?? []).every((child) => isNavigationPart(child, anchors));
+};
+
+const containsInPageLink = (node: NavNode, anchors: InPageAnchors): boolean =>
+  isInPageLink(node, anchors) || (node.children ?? []).some((child) => containsInPageLink(child, anchors));
+
+/**
+ * 同じページの中へのリンク（`](#…)`）と記号だけでできた段落。「▲ 目次に戻る」や目次の項目で、本文ではなくページの案内。
+ * 言葉が 1 つでも混ざれば本文（「詳しくは[第3章](#第3章)を参照」）。他のページへのリンクは書いた人が選んだ一覧なので残す。
+ */
+export const isInPageNavigation = (paragraph: NavNode, anchors: InPageAnchors = new Set()): boolean => {
+  const children = paragraph.children ?? [];
+  return (
+    paragraph.type === "paragraph" &&
+    children.every((child) => isNavigationPart(child, anchors)) &&
+    children.some((child) => containsInPageLink(child, anchors))
+  );
+};
+
+const isNavigationBlock = (node: NavNode, anchors: InPageAnchors): boolean => isInPageNavigation(node, anchors) || isNavigationList(node, anchors);
+
+const isNavigationItem = (item: NavNode, anchors: InPageAnchors): boolean => {
+  const children = item.children ?? [];
+  return item.type === "listItem" && children.length > 0 && children.every((child) => isNavigationBlock(child, anchors));
+};
+
+/** 項目がどれもページの案内（入れ子も含む）の箇条書き。目次の項目の数は節の数で決まり、書いた人が選んだ並べ方ではない。 */
+export const isNavigationList = (list: NavNode, anchors: InPageAnchors = new Set()): boolean => {
+  const items = list.children ?? [];
+  return list.type === "list" && items.length > 0 && items.every((item) => isNavigationItem(item, anchors));
+};

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/orthography.ts

@@ -1,6 +1,6 @@
 // 表記のそろい。書き方の決まりのうち、文字だけで決まるもの。
 
-const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+export const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 
 /** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
 const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
@@ -67,6 +67,7 @@ const ALPHANUMERIC = /[A-Za-z0-9.]/u;
 /**
  * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
  * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ * 逆に「H30 等」「EC2 で」は英字で始まる名前で、書き手は英単語と同じに空ける。数字の後ろとしては数えない。
  */
 const runStart = (chars: readonly string[], last: number): string | undefined => {
   let first = last;
@@ -74,10 +75,10 @@ const runStart = (chars: readonly string[], last: number): string | undefined =>
   return chars[first];
 };
 
-/** 左の並びの種類。数字で始まる並び（3GB、10ms）は数字として扱う。 */
+/** 左の並びの種類は先頭の字で決める。数字で始まる並び（3GB、10ms）は数字、英字で始まる並び（H30、v1.2）は英字。 */
 const leftRunBeside = (chars: readonly string[], last: number, japanese: string | undefined): SpacingKind | undefined => {
   const kind = latinBeside(japanese, chars[last], "after-digit");
-  return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
+  return kind === undefined ? undefined : (kindOf(runStart(chars, last), "after-digit") ?? kind);
 };
 
 /**

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,15 @@ 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;
+  /** 語が、かかる語のどちら側に立つか。語順が言語で違うものを語彙表が言う（範囲の「で」は前、"in" は後ろ）。 */
+  readonly position?: "before" | "after" | undefined;
+  /** pattern を adapter が語に分けたもの。品詞が読めるときだけ core が入れる。語彙表を書く側は書かない。 */
+  readonly tokens?: readonly Token[] | undefined;
+};
 
 export type Lexicon = readonly LexiconEntry[];
 
@@ -338,11 +346,15 @@ export type RuleDefinition = {
   readonly by_genre: Readonly<Record<string, LevelTable>>;
   readonly how_to_find: string;
   readonly word_list: string | undefined;
+  /** word_list のほかに detector が名前で引く語彙表。どれかが無い言語では rule を動かさない。 */
+  readonly extra_word_lists: readonly string[];
   /** L4 のみ。LLM に渡す決まり。言語別。 */
   readonly what_to_check: Localized | undefined;
   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

@@ -99,9 +99,11 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     by_genre: genreTables(raw["by_genre"], language),
     how_to_find: String(raw["how_to_find"]),
     word_list: typeof raw["word_list"] === "string" ? raw["word_list"] : undefined,
+    extra_word_lists: stringList(raw["extra_word_lists"]) ?? [],
     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

@@ -4,8 +4,11 @@ import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
 import { joinWords } from "./detectors/word-list.ts";
+import { missingList } from "./declared-lists.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 +54,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 +108,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 => {
@@ -178,15 +182,15 @@ export const runRules = (
       const detector = DETECTORS[rule.how_to_find];
       if (detector === undefined)
         return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noDetector(rule.how_to_find) }] };
+      // 語彙表を要求する rule で、その言語に語彙表が無ければ動かせない。黙って通さない。
+      const absent = missingList(rule, doc.lexicons);
+      if (absent !== undefined)
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noLexicon(doc.language, absent) }] };
       const options = {
         limit: limitFor(rule, level, genre, limits),
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
       };
-      // 語彙表を要求する rule で、その言語に語彙表が無ければ動かせない。黙って通さない。
-      if (rule.word_list !== undefined && options.lexicon === undefined) {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noLexicon(doc.language, rule.word_list) }] };
-      }
       const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
       return { findings: [...acc.findings, ...found], skipped: acc.skipped };
     },

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));