chaffjs 0.11.0 → 0.13.0

package/src/document.ts

@@ -4,16 +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, 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;
 };
@@ -93,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);
   });
@@ -136,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;
 };
@@ -162,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);
   });
@@ -218,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) => {
@@ -263,13 +269,15 @@ export const buildDocument = (
   profile: DocumentProfile | undefined = undefined,
 ): ProseDocument => {
   const root = parse(source);
+  const anchors = inPageAnchors(root);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
   // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
-  const blocks = [...collectMasks(root, source), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
+  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 = {
@@ -292,7 +300,7 @@ export const buildDocument = (
     sentences,
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
-    lists: listsOf(root, source),
+    lists: listsOf(root, source, anchors),
     lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。

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/number-name.ts

@@ -0,0 +1,68 @@
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 数量ではなく名前として書かれた数（番号・識別子）。鉤括弧で引いた「3.1 リサーチの原則」の節番号、※1 のような注の番号、
+ * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
+ * 空け方を数える材料にしない。
+ *
+ * 形で名前と読むのは三つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）。
+ * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
+ * 品詞が無ければ判断せず、名前とは読まない。
+ */
+
+/** 数と結びついて読まれる語。助数詞は NounType=Class、数は NumType=Card で渡る。 */
+const BOUND_TO_NUMBER = new Set(["ADP", "PART", "AUX", "SCONJ", "CCONJ"]);
+
+/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印。 */
+const LABEL_LEAD = /[「『【※]$/u;
+
+/** 文頭（前に空白と箇条書きの印だけ）。 */
+const LINE_HEAD = /^[\s\-*+・•]*$/u;
+
+/** 階層つきの節番号（2.1、3.1.2）。 */
+const SECTION_NUMBER = /^\d+(?:\.\d+)+$/u;
+
+/**
+ * 0 で始まる組を含む、ハイフンでつないだ番号（〒102-0094、03-3501）。二つの数だけの「3-5」は範囲（3-5 営業日）とも読めるので
+ * 数え続ける。三つ以上つないだもの（073-489-5909）は、orthography.ts が境目を作る前に外している。
+ */
+const isHyphenIdentifier = (digits: string): boolean => {
+  const parts = digits.split("-").filter((part) => part !== "");
+  return parts.length > 1 && parts.some((part) => part.startsWith("0"));
+};
+
+const RUN_CHAR = /[\d.-]/u;
+
+/** at を含む、数字・小数点・ハイフンの並び。at が並びの中に無ければ undefined。 */
+export const digitRunAround = (text: string, at: number): Span | undefined => {
+  if (!RUN_CHAR.test(text[at] ?? "")) return undefined;
+  const startAt = (index: number): number => (index > 0 && RUN_CHAR.test(text[index - 1] ?? "") ? startAt(index - 1) : index);
+  const endAt = (index: number): number => (index < text.length && RUN_CHAR.test(text[index] ?? "") ? endAt(index + 1) : index);
+  return { start: startAt(at), end: endAt(at) };
+};
+
+/** 並びの後ろ（空白 1 つまで）で始まる語。 */
+const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: number): Token | undefined => {
+  const next = text[run.end] === " " ? run.end + 1 : run.end;
+  return tokens.find((token) => token.span.start === base + next);
+};
+
+const isBoundToNumber = (token: Token): boolean =>
+  token.features?.["NounType"] === "Class" || token.features?.["NumType"] === "Card" || BOUND_TO_NUMBER.has(token.pos);
+
+/** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
+const isNameShaped = (text: string, run: Span): boolean => {
+  const [before, digits] = [text.slice(0, run.start), text.slice(run.start, run.end)];
+  return isHyphenIdentifier(digits) || LABEL_LEAD.test(before) || (LINE_HEAD.test(before) && SECTION_NUMBER.test(digits));
+};
+
+/**
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。
+ * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
+ */
+export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number): boolean => {
+  if (tokens === undefined || !isNameShaped(text, run)) return false;
+  const next = wordAfter(tokens, text, run, base);
+  return next !== undefined && !isBoundToNumber(next);
+};

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][] => {
@@ -62,22 +62,53 @@ const latinBeside = (japanese: string | undefined, other: string | undefined, di
   isJapanese(japanese) ? kindOf(other, digitSide) : undefined;
 
 /** 日本語の字の隣にある英字・数字との境目。間が半角空白 1 つなら「空けている」、何も無ければ「詰めている」。 */
-const ALPHANUMERIC = /[A-Za-z0-9.]/u;
+// 「confidence=0」のような設定の書き方も、= を含めて一つの並びとして読む。
+const ALPHANUMERIC = /[A-Za-z0-9.=]/u;
+// 名前の語は英数字だけ。「API = 0」の空白で囲んだ = は式の記号で、名前の一部ではない。
+const WORD_CHAR = /[A-Za-z0-9.]/u;
+
+/** chars[last] を末尾とし、pattern の字が続く並びの、先頭の位置。 */
+const runStartIndex = (chars: readonly string[], last: number, pattern: RegExp = ALPHANUMERIC): number => {
+  let first = last;
+  while (first > 0 && pattern.test(chars[first - 1] ?? "")) first -= 1;
+  return first;
+};
+
+/** 並び first の前に、半角空白 1 つずつで続く英数字の語。「Phase 1」の「Phase」、「JIS X 0301」の「JIS X」。無ければ空。 */
+const wordsBefore = (chars: readonly string[], first: number): string => {
+  const words: string[] = [];
+  let space = first - 1;
+  while (chars[space] === " " && WORD_CHAR.test(chars[space - 1] ?? "")) {
+    const start = runStartIndex(chars, space - 1, WORD_CHAR);
+    words.unshift(chars.slice(start, space).join(""));
+    space = start - 1;
+  }
+  return words.join(" ");
+};
+
+// 「1ファイル x 1シート」の x のように、1 字だけの英字は記号か変数で、名前の頭ではない。
+const MIN_NAME_LETTERS = 2;
 
 /**
- * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
- * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ * 「Phase 1 は」「iOS 17以上」の数字は、英字の語に続く名前の一部。空白は名前の中の空白で、日本語との境目は
+ * 「H30 等」と同じく英字の空け方として数える。
  */
-const runStart = (chars: readonly string[], last: number): string | undefined => {
-  let first = last;
-  while (first > 0 && ALPHANUMERIC.test(chars[first - 1] ?? "")) first -= 1;
-  return chars[first];
+const isNameTail = (chars: readonly string[], first: number): boolean => {
+  const words = wordsBefore(chars, first);
+  return LETTER.test(words[0] ?? "") && (words.match(/[A-Za-z]/gu)?.length ?? 0) >= MIN_NAME_LETTERS;
 };
 
-/** 左の並びの種類。数字で始まる並び（3GB、10ms）は数字として扱う。 */
+/**
+ * 日本語の左にある英数字の並びの種類は、先頭の字で決める。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
+ * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ * 逆に「H30 等」「EC2 で」「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;
+  if (kind === undefined) return undefined;
+  const first = runStartIndex(chars, last);
+  if (DIGIT.test(chars[first] ?? "") && isNameTail(chars, first)) return "letter";
+  return kindOf(chars[first], "after-digit") ?? kind;
 };
 
 /**
@@ -93,10 +124,37 @@ const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
   return chars[before] === ORDINAL_PREFIX;
 };
 
+/**
+ * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」のように - でつないだ 3 組以上の数字は、電話番号・日付・図の番号で
+ * 数量ではない。後ろの空白は欄の区切りで、「3回」の空け方とは別のもの。両側とも数えない。
+ * 2 組（「1-3ヶ月」「20-30分」）は幅のある数量なので数える。
+ */
+const MIN_CODE_GROUPS = 3;
+const CODE_CHAR = /[\d-]/u;
+
+const isCode = (chars: readonly string[], digit: number): boolean => {
+  let [first, last] = [digit, digit];
+  while (first > 0 && CODE_CHAR.test(chars[first - 1] ?? "")) first -= 1;
+  while (last < chars.length - 1 && CODE_CHAR.test(chars[last + 1] ?? "")) last += 1;
+  const groups = chars
+    .slice(first, last + 1)
+    .join("")
+    .split("-");
+  return groups.filter((group) => group !== "").length >= MIN_CODE_GROUPS;
+};
+
+/** 日本語との境目にある数字が、数えない書き方（「第3条」の番地、「073-489-5909」の符号）か。 */
+const isUncountedNumber = (chars: readonly string[], index: number): boolean => {
+  const [left, right] = [chars[index], chars[index + 1]];
+  if (DIGIT.test(left ?? "")) return isOrdinalRun(chars, index) || isCode(chars, index);
+  const next = right === " " ? index + 2 : index + 1;
+  if (!DIGIT.test(chars[next] ?? "")) return false;
+  return left === ORDINAL_PREFIX || (isJapanese(left) && isCode(chars, next));
+};
+
 const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  if (isUncountedNumber(chars, index)) return undefined;
   const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
-  const numberAfterPrefix = left === ORDINAL_PREFIX && DIGIT.test((right === " " ? after : right) ?? "");
-  if (numberAfterPrefix || (DIGIT.test(left ?? "") && isOrdinalRun(chars, index))) return undefined;
   const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
   if (touching !== undefined) return { kind: touching, spaced: false };
   if (right !== " ") return undefined;
@@ -104,15 +162,19 @@ const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "of
   return spaced === undefined ? undefined : { kind: spaced, spaced: true };
 };
 
-/** 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。 */
-export const latinBoundaries = (text: string): Boundary[] => {
+/**
+ * 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。
+ * text は本文でないものを空白で覆った文、written は覆う前の同じ範囲。覆ってできた空白（リンクの「[」など）は
+ * 書き手が空けたものではないので、「空けている」とは数えない。
+ */
+export const latinBoundaries = (text: string, written: string = text): Boundary[] => {
   const chars = [...text];
   const found: Boundary[] = [];
   let offset = 0;
   chars.forEach((char, index) => {
     offset += char.length;
     const boundary = boundaryAt(chars, index);
-    if (boundary !== undefined) found.push({ ...boundary, offset });
+    if (boundary !== undefined && (!boundary.spaced || written[offset] === " ")) found.push({ ...boundary, offset });
   });
   return found;
 };

package/src/plugin.ts

@@ -40,6 +40,8 @@ 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;
 };
@@ -344,6 +346,8 @@ 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;

package/src/rule-load.ts

@@ -99,6 +99,7 @@ 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"]) ?? [],

package/src/run.ts

@@ -4,6 +4,7 @@ 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";
@@ -181,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 };
     },