chaffjs 0.33.0 → 0.35.0

package/src/detectors/char-shape.ts

@@ -1,9 +1,11 @@
-import type { Detector, DocumentProfile, Finding, Sentence, Span, Token } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { compacted } from "./gram-place.ts";
-import { leadingCounter } from "./counter-edge.ts";
+import { leadingCounter, trailingPrefix } from "./counter-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
+import { isOrganisationRun, type OrganisationWords } from "./organisation-run.ts";
+import { endsInTitle, isTitlePosition, isTitledName, type TitleWords } from "./titled-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
 import { maskSpans } from "../mask.ts";
@@ -16,11 +18,17 @@ import { nameSpans } from "../team-names.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりと、その文書全体の座標での範囲。quoted は鉤括弧の中身がまるごとこの連なりであること。 */
-type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean };
+/**
+ * 漢字の連なりと、その文書全体の座標での範囲。quoted は括弧の中身がまるごとこの連なりであること。
+ * placed は、題の名前の置き方（括弧を閉じる、補いの括弧が続く、文がこれだけ）をしていること。
+ */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean; readonly placed: boolean };
 
 const SPACE = /\s/gu;
 
+/** 名前を囲む括弧。鉤括弧と、見出しや分類の名前を囲む隅付き括弧（【浪速区役所公募型比較見積】）。 */
+const NAME_MARKS = { "「": "」", "『": "』", "【": "】" };
+
 /**
  * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
  * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
@@ -29,9 +37,9 @@ const SPACE = /\s/gu;
 const maskedProse = (prose: string, profile: DocumentProfile | undefined, names: readonly string[]): string =>
   maskSpans(maskAddresses(prose, profile), nameSpans(prose, names));
 
-/** 鉤括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
+/** 鉤括弧と隅付き括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
 const fillsQuote = (sentence: Sentence, start: number, end: number): boolean =>
-  quotedSpans(sentence.text).some((span) => span.start === start && span.end === end);
+  quotedSpans(sentence.text, NAME_MARKS).some((span) => span.start === start && span.end === end);
 
 const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names: readonly string[]): KanjiRun[] => {
   const prose = proseText(sentence);
@@ -39,42 +47,86 @@ const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names:
   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]];
-    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) };
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false, placed: false };
+    const span = { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
+    return { text: match[0], span, quoted: fillsQuote(sentence, start, last + 1), placed: isTitlePosition(sentence.text, start, last + 1) };
   });
 };
 
-/** 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か。形態素解析の地名・人名・組織名と数で決める。 */
-const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet<string>): boolean => {
-  const covering = tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
-  return isAddressRun(tokens, covering, topUnits) || isOneName(tokens, covering);
+/** 連なりを数えないと決める語彙: 住所の先頭にしか来ない単位（都道府県）と、組織の名前の形と単位と、題の名前を閉じる語。 */
+type NameWords = { readonly topUnits: ReadonlySet<string>; readonly organisation: OrganisationWords; readonly title: TitleWords };
+
+/** 1 つの文書で連なりを読むのに要るもの。titled は、文書の中で題として置かれた名前（titledNames）。 */
+type RunContext = {
+  readonly profile: DocumentProfile | undefined;
+  readonly names: readonly string[];
+  readonly words: NameWords;
+  readonly titled: readonly string[];
 };
 
+const coveringOf = (tokens: readonly Token[], span: Span): number[] =>
+  tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
+
 /**
- * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）は数えない。
- * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ * 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か 1 つの組織の名前（国立研究開発法人産業技術総合研究所）か。
+ * 形態素解析の地名・人名・組織名と数、組織の語彙で決める。
  */
-const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+const isPlaceName = (tokens: readonly Token[], span: Span, words: NameWords): boolean => {
+  const covering = coveringOf(tokens, span);
+  return isAddressRun(tokens, covering, words.topUnits) || isOneName(tokens, covering) || isOrganisationRun(tokens, covering, words.organisation);
+};
+
+/** 題の名前（大阪市鶴見区役所公募型比較見積実施要綱）か。題を閉じる語で終わり、ここか文書のほかの所で題として置かれている。 */
+const isTitle = (tokens: readonly Token[], span: Span, text: string, placed: boolean, context: RunContext): boolean =>
+  endsInTitle(
+    coveringOf(tokens, span).flatMap((index) => tokens.slice(index, index + 1)),
+    context.words.title,
+  ) &&
+  (placed || isTitledName(text, context.titled));
+
+/**
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）と、尻の、数に付く接頭の語（施行令第172条の「第」）は数えない。
+ * 住所か名前かは、それを外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ */
+const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, context: RunContext): 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 prefix = trailingPrefix(tokens, run.span.end, run.text);
+  const rest = { start: counter?.span.end ?? run.span.start, end: prefix?.span.start ?? run.span.end };
+  const text = run.text.slice(counter?.surface.length ?? 0, run.text.length - (prefix?.surface.length ?? 0));
+  return isPlaceName(tokens, rest, context.words) || isTitle(tokens, rest, text, run.placed, context) ? "" : text;
 };
 
-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))
+const longestKanji = (sentence: Sentence, context: RunContext): string =>
+  runsOf(sentence, context.profile, context.names)
+    .map((run) => measuredRun(sentence.tokens, run, context))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
+/**
+ * 文書の中で題として置かれた漢字の連なり: 題の置き方をした文の中の連なりと、見出しの中の連なり。
+ * 同じ名前を文の中で使えば（認定職業訓練実施奨励金の支給額）、それも題の名前と読む。
+ */
+const titledNames = (doc: ProseDocument, profile: DocumentProfile | undefined, names: readonly string[]): string[] => [
+  ...doc.sentences.flatMap((sentence) => runsOf(sentence, profile, names).flatMap((run) => (run.placed ? [run.text] : []))),
+  ...(doc.markup?.headings ?? []).flatMap((heading) => [...heading.text.matchAll(KANJI_RUN)].map((match) => match[0])),
+];
+
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
  * 「情報処理推進機構認定試験」は 12 字。ひらがなを 1 つ挟むだけで読める。
  */
 export const kanjiRun: Detector = (doc, options): Finding[] => {
-  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  const patterns = (id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+  const words: NameWords = {
+    topUnits: new Set(patterns("prefecture-unit")),
+    organisation: { forms: patterns("organisation-form"), units: patterns("organisation-unit") },
+    title: { endings: patterns("title-ending") },
+  };
+  const names = doc.names ?? [];
+  const context: RunContext = { profile: doc.profile, names, words, titled: titledNames(doc, doc.profile, names) };
   return doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits, doc.names ?? []) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, context) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",

package/src/detectors/clause-shape.ts

@@ -1,5 +1,6 @@
 import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import { definitionWordsOf, isParallelDefinition } from "./parallel-definition.ts";
 
 // The shape of a clause read from its words: how it ends, a paired word left alone, an adverb that needs a
 // negation, a particle used where another one belongs. Every word comes from a lexicon; this file knows parts of speech.
@@ -74,13 +75,22 @@ const runFinding = (run: readonly Ended[], limit: number): Finding => {
   };
 };
 
-/** More than limit sentences in a row within one paragraph that end with the same words. */
-export const endingRun: Detector = (doc, options): Finding[] =>
-  doc.paragraphs.flatMap((paragraph) =>
+/** More than limit sentences in a row within one paragraph that end with the same words, unless they define different terms in one frame. */
+export const endingRun: Detector = (doc, options): Finding[] => {
+  const words = definitionWordsOf(options.lexicon);
+  return doc.paragraphs.flatMap((paragraph) =>
     endingRuns(paragraph.sentences)
-      .filter((run) => run.length > options.limit)
+      .filter(
+        (run) =>
+          run.length > options.limit &&
+          !isParallelDefinition(
+            run.map(({ sentence }) => sentence),
+            words,
+          ),
+      )
       .map((run) => runFinding(run, options.limit)),
   );
+};
 
 // --- unpaired-parallel: a word that lists by pairs (〜たり) used once, followed by another clause -----------------
 

package/src/detectors/closing-balance-mismatch.ts

@@ -20,6 +20,7 @@ const wordsOf = (doc: ProseDocument): BalanceWords => ({
     outflow: patternsOf(doc, LEXICON, "outflow"),
     closing: patternsOf(doc, LEXICON, "closing"),
   },
+  asOf: patternsOf(doc, LEXICON, "as-of"),
   magnitudes: patternsOf(doc, "amount-multiplier"),
   percentUnits: patternsOf(doc, "percent-unit"),
 });

package/src/detectors/code-fences.ts

@@ -3,6 +3,7 @@
 import { parse } from "../markdown-read.ts";
 import { spanOf } from "../markdown-node.ts";
 import { eachPreOrder } from "../tree-walk.ts";
+import { maskSpans } from "../mask.ts";
 
 export type CodeFence = {
   /** Where the opening fence line starts. */
@@ -79,6 +80,15 @@ export const codeFences = (source: string): readonly CodeFence[] => {
   return fences;
 };
 
+/**
+ * The source with every fenced code block blanked, offsets and line breaks kept. A list or a sentence in a code block is an
+ * example, not the document's own: a rule that reads values from the source line by line reads this instead.
+ */
+export const withoutCodeBlocks = (source: string): string => {
+  const fences = codeFences(source);
+  return fences.length === 0 ? source : maskSpans(source, fences);
+};
+
 /** Inline code spans in a stretch of text: a run of backticks closed by a run of the same length. */
 export const codeSpans = (text: string, offset = 0): CodeSpan[] => {
   const spans: CodeSpan[] = [];

package/src/detectors/concrete-evidence.ts

@@ -1,5 +1,6 @@
-import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+import type { Sentence, Span, StructureKind, StructureNode, Token } from "../plugin.ts";
 import { preOrder } from "../tree-walk.ts";
+import { isStatement } from "./technical-docs.ts";
 
 /**
  * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
@@ -30,3 +31,78 @@ const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "
 
 export const evidenceSpans = (root: StructureNode | undefined): Span[] =>
   root === undefined ? [] : preOrder(root).flatMap((node) => (EVIDENCE.has(node.kind) ? [node.span] : []));
+
+/** 読み手にすることを伝える言い方。英語は文の書き出し（Never use, Please submit）、日本語は文末（〜ください、〜しましょう）。 */
+export type AdviceWords = { readonly openers: readonly string[]; readonly endings: readonly string[] };
+
+const CLOSERS = new Set(Array.from("\"'”’」』）)】〕〉》］]"));
+const TERMINALS = new Set(Array.from("。．.!！"));
+const QUESTION_MARKS = new Set(["?", "？"]);
+const SKIPPED = new Set(["PUNCT", "SYM", "X", "SPACE"]);
+
+/** 文末から、閉じ括弧・引用符（と、渡されれば句点）を外した残り。 */
+const withoutTail = (text: string, tail: ReadonlySet<string>): string => {
+  const chars = Array.from(text.trimEnd());
+  const last = chars.findLastIndex((char) => !tail.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+const isQuestion = (text: string): boolean => QUESTION_MARKS.has(Array.from(withoutTail(text, CLOSERS)).at(-1) ?? "");
+
+const opensWith = (text: string, openers: readonly string[]): boolean => {
+  const lower = text.trimStart().toLowerCase();
+  return openers.some((opener) => lower.startsWith(`${opener} `));
+};
+
+const endsWith = (text: string, endings: readonly string[]): boolean => {
+  const body = withoutTail(text, new Set([...CLOSERS, ...TERMINALS]));
+  return endings.some((ending) => body.endsWith(ending));
+};
+
+/** 項目の番号（a, 12, iv）。 */
+const ENUMERATOR = /^(?:\p{L}|\p{Nd}{1,3}|[ivx]{1,4})$/iu;
+const BRACKETED = /^[(（](.+)[)）]$/u;
+const MARKED = /^(.+)[.)）．]$/u;
+
+/** 項目の番号だけが文として切り出されたもの（a. や (1)）。述べることも問うことも無い。 */
+export const isLabelOnly = (sentence: Pick<Sentence, "text">): boolean => {
+  const text = sentence.text.trim();
+  const core = BRACKETED.exec(text)?.[1] ?? MARKED.exec(text)?.[1];
+  return core !== undefined && ENUMERATOR.test(core);
+};
+
+/** 動詞の目的語の書き出し（Use a generator, Review our benefits）。名詞と読まれた語の後ろにこれが来れば、その語は動詞。 */
+const OBJECT_OPENER = new Set(["DET", "PRON"]);
+
+/**
+ * 原形の動詞（Keep, Take）。解析器が名詞と読んだ、動詞にもなる語も、目的語が続けば同じ（Use a generator）。
+ * 後ろが名詞や前置詞なら名詞句の頭（evidence of complexity, trust development plans）。
+ */
+const isBaseVerb = (token: Token, next: Token | undefined): boolean =>
+  (token.pos === "VERB" && token.lemma?.toLowerCase() === token.surface.toLowerCase() && token.features?.["VerbForm"] === undefined) ||
+  (token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] !== "Plur" && OBJECT_OPENER.has(next?.pos ?? ""));
+
+/** 頭の語が一語として立っている。空白を置かずに続けば、語の一部（Cloud.gov の Cloud）。 */
+const standsAlone = (tokens: readonly Token[], head: Token): boolean => {
+  const after = tokens[tokens.indexOf(head) + 1];
+  return after === undefined || after.span.start > head.span.end || after === tokens.at(-1) || after.surface === ",";
+};
+
+/**
+ * 動詞で始まる英語の文（Keep freezers closed）は指示。すぐ後ろがコロンなら見出し語（Release: none）で、主語のある文は述べる文。
+ * 日本語は動詞が文末に来るので、品詞では読まない。
+ */
+const opensWithVerb = (tokens: readonly Token[], language: string): boolean => {
+  const [head, next] = tokens.filter((token) => !SKIPPED.has(token.pos) || token.surface === ":");
+  return language === "en" && head !== undefined && isBaseVerb(head, next) && standsAlone(tokens, head) && next?.surface !== ":" && !isStatement(tokens);
+};
+
+/**
+ * 読み手が裏づけを求められることを述べた文。問い（情報提供の依頼に並ぶ質問）と指示（安全の手引き）は主張ではなく、
+ * 数字が欠けているとは言えない。
+ */
+export const isClaim = (sentence: Pick<Sentence, "text" | "tokens">, language: string, words: AdviceWords): boolean =>
+  !isQuestion(sentence.text) &&
+  !opensWith(sentence.text, words.openers) &&
+  !endsWith(sentence.text, words.endings) &&
+  !opensWithVerb(sentence.tokens ?? [], language);

package/src/detectors/condition-toki.ts

@@ -0,0 +1,60 @@
+import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+
+// A noun for a point in time written where the clause states a condition (認定を受けた時は → 認定を受けたときは). One word
+// list gives the noun and its kana form, another the particles that make the clause a condition; this file knows parts of
+// speech. Pure: the sentence and the word lists come in.
+
+export type ConditionWords = { readonly nouns: ReadonlyMap<string, string>; readonly followers: ReadonlySet<string> };
+
+export type ConditionSpelling = { readonly written: string; readonly preferred: string; readonly offset: number };
+
+/** A predicate ends the clause before the noun (受けた時, 過ぎる時, 支払わない時, 必要な時); の, その and ある (事故の時, その時) do not. */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX", "ADJ"]);
+
+const FOLLOWER_LIST = "condition-follower";
+
+/** The nouns with their rewrite (時 → とき), and the particles that follow them in a condition (は, には, も). */
+export const conditionWordsOf = (nouns: Lexicon | undefined, followers: Lexicon | undefined): ConditionWords => ({
+  nouns: new Map((nouns ?? []).flatMap((entry): [string, string][] => (entry.rewrite === undefined ? [] : [[entry.pattern, entry.rewrite]]))),
+  followers: new Set((followers ?? []).map((entry) => entry.pattern)),
+});
+
+/** The follower right after index: one particle (は, も) or two the tagger splits (に + は). */
+const isFollowedByCondition = (tokens: readonly Token[], index: number, followers: ReadonlySet<string>): boolean => {
+  const next = tokens[index + 1]?.surface ?? "";
+  const pair = `${next}${tokens[index + 2]?.surface ?? ""}`;
+  return followers.has(next) || followers.has(pair);
+};
+
+const isConditionNoun = (tokens: readonly Token[], index: number, words: ConditionWords): boolean => {
+  const token = tokens[index];
+  if (token === undefined || !words.nouns.has(token.surface)) return false;
+  const previous = tokens[index - 1];
+  return previous !== undefined && PREDICATE_POS.has(previous.pos) && isFollowedByCondition(tokens, index, words.followers);
+};
+
+/** Each noun in the sentence, outside 「」『』, that ends a predicate and is followed by は, には or も. */
+export const conditionSpellingsIn = (sentence: Sentence, words: ConditionWords): ConditionSpelling[] => {
+  const tokens = sentence.tokens ?? [];
+  const quoted = quotedIn(sentence);
+  return tokens.flatMap((token, index) =>
+    isConditionNoun(tokens, index, words) && !isWithinAny(quoted, token.span)
+      ? [{ written: token.surface, preferred: words.nouns.get(token.surface) ?? "", offset: token.span.start }]
+      : [],
+  );
+};
+
+export const conditionToki: Detector = (doc, options): Finding[] => {
+  const words = conditionWordsOf(options.lexicon, doc.lexicons[FOLLOWER_LIST]);
+  return doc.sentences.flatMap((sentence) =>
+    conditionSpellingsIn(sentence, words).map((spelling) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: spelling.written, preferred: spelling.preferred, offset: spelling.offset },
+    })),
+  );
+};

package/src/detectors/conjugated-entry.ts

@@ -0,0 +1,53 @@
+import type { LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { entryRanges } from "./lexicon-match.ts";
+
+/**
+ * チームが辞書形の動詞で書いた語か（巻き取る・握っておく・utilize）。最後の語が動詞の原形のときだけ。
+ * 名詞（巻き取り・onboarding）や活用した形（握った）は書いた形のまま照らす。動詞の名詞形まで当てると、チームが並べていない語を指摘する。
+ */
+export const isDictionaryVerb = (entry: LexiconEntry): boolean => {
+  const last = entry.tokens?.at(-1);
+  return last?.pos === "VERB" && last.lemma?.toLowerCase() === last.surface.toLowerCase();
+};
+
+/** 直前に動詞が詰めて書いてある（受け|取ります）。そこは別の複合動詞の後ろ半分で、並べた動詞ではない。 */
+const tailOfCompound = (tokens: readonly Token[], start: number): boolean => {
+  const before = tokens[start - 1];
+  return before?.pos === "VERB" && before.span.end === tokens[start]?.span.start;
+};
+
+/**
+ * 辞書形の動詞で書いた語が、活用した形で文のどこに出たか（文の中の字の範囲）。複合動詞は語に割れる（巻き/取り）ので、語の並びで照らす。
+ * 品詞が無い文書、動詞でない語には何も返さない。字で探す側がそのまま当たる。
+ */
+export const conjugatedSpans = (sentence: Sentence, entry: LexiconEntry): Span[] => {
+  const tokens = sentence.tokens;
+  if (tokens === undefined || !isDictionaryVerb(entry)) return [];
+  return entryRanges(sentence, entry).flatMap((range) => {
+    const first = tokens[range.start];
+    const last = tokens[range.end - 1];
+    if (first === undefined || last === undefined || tailOfCompound(tokens, range.start)) return [];
+    return [{ start: first.span.start - sentence.span.start, end: last.span.end - sentence.span.start }];
+  });
+};
+
+const occurrencesOf = (text: string, word: string): Span[] =>
+  word === ""
+    ? []
+    : [...text.matchAll(new RegExp(escapeRegExp(word), "giu"))].map((match) => ({
+        start: match.index,
+        end: match.index + match[0].length,
+      }));
+
+/**
+ * prefer の「使わない書き方」が動詞のとき、活用した形の始まり（文の中の字の位置）。「使う書き方」の中に出たものは除く。
+ * 大文字小文字だけ違う組（Javascript・JavaScript）は語で照らすと区別が消えるので、字で探す側に任せる。
+ */
+export const conjugatedStartsOutside = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
+  if (entry.pattern.toLowerCase() === use.toLowerCase()) return [];
+  const covered = occurrencesOf(sentence.text, use);
+  return conjugatedSpans(sentence, entry)
+    .filter((span) => !covered.some((cover) => cover.start <= span.start && span.end <= cover.end))
+    .map((span) => span.start);
+};

package/src/detectors/content-morphemes.ts

@@ -7,7 +7,8 @@ import type { Token } from "../plugin.ts";
 const CONTENT_POS = new Set(["NOUN", "PROPN", "NUM", "VERB", "ADJ", "ADV"]);
 
 /** 接頭詞・接尾・非自立の語（Bound）と、動詞にするだけの「する」（VerbType=Light）は、付いた語が中身を持つ。 */
-const isContent = (token: Token): boolean => CONTENT_POS.has(token.pos) && token.features?.["Bound"] !== "Yes" && token.features?.["VerbType"] !== "Light";
+export const isContent = (token: Token): boolean =>
+  CONTENT_POS.has(token.pos) && token.features?.["Bound"] !== "Yes" && token.features?.["VerbType"] !== "Light";
 
 /** 原形で照らす（変えました → 変える）。原形の無い語は書いた形で。 */
 const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();

package/src/detectors/contraction-minority.ts

@@ -0,0 +1,11 @@
+/** 1 つの対（「don't」と「do not」）が、文書の中でそれぞれ何回出てくるか。 */
+export type PairUses = { readonly short: number; readonly long: number };
+
+/**
+ * その対で少ないほうの書きかた。"short" なら短縮形、"long" なら長い形、少数派が無ければ undefined。
+ * 片方しか出てこない対は揃っている。両方が同じ回数なら、どちらを指しても当て推量になる。
+ */
+export const pairMinority = (uses: PairUses): "short" | "long" | undefined => {
+  if (uses.short === 0 || uses.long === 0 || uses.short === uses.long) return undefined;
+  return uses.short < uses.long ? "short" : "long";
+};

package/src/detectors/counter-edge.ts

@@ -27,3 +27,26 @@ export const leadingCounter = (tokens: readonly Token[], start: number, run: str
   if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
   return run.startsWith(counter.surface) ? counter : undefined;
 };
+
+const isPrefix = (token: Token | undefined): boolean => token?.pos === "ADJ" && token.features?.["Bound"] === "Yes";
+
+/** at の語のすぐ後ろの語。空白一つ（改行を含む）を挟んでもよい（「第\n172条」）。 */
+const wordAfter = (tokens: readonly Token[], at: number): Token | undefined => {
+  const [token, next] = [tokens[at], tokens[at + 1]];
+  if (token === undefined || next === undefined || !touches(token, next)) return undefined;
+  if (!BLANK.test(next.surface)) return next;
+  const beyond = tokens[at + 2];
+  return beyond !== undefined && touches(next, beyond) ? beyond : undefined;
+};
+
+/**
+ * 漢字の連なり run（文書全体の座標で end に終わる）の尻が、すぐ後ろの数に付く接頭の語（地方自治法施行令第172条の「第」）なら、その語。
+ * 接頭の語は後ろの数の一部で、前の複合語の一部ではない。そうでなければ undefined。
+ */
+export const trailingPrefix = (tokens: readonly Token[], end: number, run: string): Token | undefined => {
+  // 折り返しをまたぐ語は span が surface より長いので、end で終わる語ではなく end の直前の字を覆う語を探す。
+  const at = tokens.findIndex((token) => token.span.start < end && end <= token.span.end);
+  const prefix = tokens[at];
+  if (prefix === undefined || !isPrefix(prefix) || !isNumber(wordAfter(tokens, at))) return undefined;
+  return run.endsWith(prefix.surface) ? prefix : undefined;
+};

package/src/detectors/cross-facts.ts

@@ -9,6 +9,7 @@ import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { factsOutOfStep, writtenValue, type FactOutOfStep } from "../facts/cross-facts.ts";
 import { factWordsOf } from "./fact-consistency.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { perUnitsOf } from "./per-unit-words.ts";
 
 // cross-doc-fact-conflict reads facts as fact-conflict does (fact-consistency.ts), with two more kinds of value that a docs
 // site repeats from page to page: an email address and a version of three parts or more (2.4.1, v3).
@@ -32,7 +33,7 @@ const COLON_BEFORE = /[:：][\s*_]*$/u;
 const isEntry = (source: string, fact: Fact): boolean => COLON_BEFORE.test(source.slice(source.lastIndexOf("\n", fact.value.start - 1) + 1, fact.value.start));
 
 const factsOf = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
-  const values = factValues(tree, doc.source, namedValues(doc));
+  const values = perUnitsOf(doc, factValues(tree, doc.source, namedValues(doc)));
   const entries = labelledFacts(doc.source, values, factWordsOf(doc)).filter((fact) => isEntry(doc.source, fact));
   return scopedFacts([...entries, ...tableFacts(doc.source, values)], tree, doc.source, summaryHeadings(doc));
 };

package/src/detectors/custom.ts

@@ -3,6 +3,8 @@ import { occurrencesOutside } from "../orthography.ts";
 import { tokenRuns } from "../custom/token-pattern.ts";
 import { joinedView, type JoinedView } from "../joined-view.ts";
 import { boundedMatches } from "../custom/bounded-match.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
+import { NO_REWRITE } from "../custom/no-rewrite.ts";
 
 // The detectors behind a team's custom_rules. Each reports every place it finds, at the rule's level; the spec comes from
 // the rule (DetectorOptions.custom). Positions are the document's, like every other finding.
@@ -18,6 +20,9 @@ const findingOf = (hit: Hit): Finding => ({
   values: { matched: hit.matched, preferred: hit.preferred, offset: hit.sentence.span.start + hit.offset },
 });
 
+/** A words finding: with no spelling to use (a word-list entry without rewrite), its rule's message for that. */
+const wordsFindingOf = (hit: Hit): Finding => ({ ...findingOf(hit), ...(hit.preferred === "" ? { variant: NO_REWRITE } : {}) });
+
 /**
  * The sentence with the line breaks that fall inside a word taken out (「関\nする」 reads 「関する」), so words and patterns
  * are found as the reader reads them. Positions found in it go back to the sentence's own.
@@ -48,7 +53,9 @@ const pairsOf = (
   spec: { readonly words: readonly { readonly avoid: string; readonly use: string }[] },
   options: DetectorOptions,
 ): readonly { avoid: string; use: string }[] =>
-  spec.words.length > 0 ? spec.words : (options.lexicon ?? []).map((entry) => ({ avoid: entry.pattern, use: entry.rewrite ?? "" }));
+  spec.words.length > 0
+    ? spec.words
+    : entriesForGenre(options.lexicon ?? [], options.genre).map((entry) => ({ avoid: entry.pattern, use: entry.rewrite ?? "" }));
 
 /** words: each spelling to avoid, outside the spelling to use (「ユーザ」 inside 「ユーザー」 is not reported). */
 export const customWords: Detector = (doc, options): Finding[] => {
@@ -58,7 +65,7 @@ export const customWords: Detector = (doc, options): Finding[] => {
   return doc.sentences.flatMap((sentence) => {
     const view = readAsWritten(sentence);
     return pairs.flatMap((pair) =>
-      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => findingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
+      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => wordsFindingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
     );
   });
 };

package/src/detectors/date-any-year.ts

@@ -9,10 +9,14 @@ export const YEAR_SPAN_JOINER_LEXICON = "year-span-joiner";
 
 /**
  * Where a marker reaches. `sentence`: earlier in the date's sentence, not closed off by a bracket (例えば…4月1日), or the
- * line a list of dates hangs from ("for example:"). `adjacent`: just before the date ("each December 31"). `label`: before
- * the bracket the date is in (年末年始閉庁日（12月29日～1月3日）).
+ * line a list of dates hangs from ("for example:"). `example`: as `sentence`, and on to the end of the list item it is in.
+ * `adjacent`: just before the date ("each December 31"). `near`: ending a few characters before it (決算日は、12月31日).
+ * `label`: before the bracket the date is in (年末年始閉庁日（12月29日～1月3日）). `continues`: opening a list item just
+ * after an example's item, it carries the example on ("- For example, … June 22." then "- If instead … June 25").
  */
-export type MarkerReach = "sentence" | "adjacent" | "label";
+export type MarkerReach = "sentence" | "example" | "adjacent" | "near" | "label" | "continues";
+
+export const MARKER_REACHES: readonly MarkerReach[] = ["sentence", "example", "adjacent", "near", "label", "continues"];
 
 export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach };
 
@@ -25,6 +29,9 @@ const SPAN_GAP_REACH = 12;
 /** How many lines above a list item its introducing line is looked for: a longer list is read as no example. */
 const LIST_REACH = 64;
 
+/** How many characters a `near` marker may end before the date: 「は、」 of 「決算日は、」, " is " of "fiscal year end is". */
+const NEAR_REACH = 4;
+
 /** The end of a sentence: 。, a line break, or a full stop before a capital or a digit ("Mar 3. The", "so. 10 November"). */
 const SENTENCE_END = /[。！？\n]|[.!?]["'”’)\]]*\s+(?=[A-Z0-9])/u;
 const OPENERS = "(（「『[【〔";
@@ -109,17 +116,56 @@ const introOf = (source: string, before: string, offset: number): string | undef
 /** The line ends with the marker, before or after its colon: 「例：」 and "for example:" alike. */
 const introEndsWith = (intro: string, word: string): boolean => isAdjacent(intro, word) || isAdjacent(intro.replace(COLON_END, ""), word);
 
+const wordsOf = (markers: readonly AnyYearMarker[], reach: MarkerReach): string[] =>
+  markers.flatMap((marker) => (marker.reach === reach && marker.word !== "" ? [latinLower(marker.word)] : []));
+
+/** A list item's text after its bullet: "If instead …" of "    - If instead …". */
+const itemText = (line: string): string => line.replace(LIST_ITEM, "");
+
+const indentOf = (line: string): number => line.length - line.trimStart().length;
+
+/** The line just above the one at `offset`, when it is a list item at the same depth (no blank line between). */
+const itemAbove = (source: string, offset: number): string | undefined => {
+  const start = lineStart(source, offset);
+  if (start === 0) return undefined;
+  const above = source.slice(lineStart(source, start - 1), start - 1);
+  return LIST_ITEM.test(above) && indentOf(above) === indentOf(source.slice(start, offset)) ? above : undefined;
+};
+
+const opensWith = (text: string, word: string): boolean => text.startsWith(word) && !runsOn(text, word);
+
+const opensWithAny = (line: string, words: readonly string[]): boolean => words.some((word) => opensWith(latinLower(itemText(line)), word));
+
+/** `item` holds an example, or carries one on from the item above it; `steps` bounds how far up the chain is followed. */
+const exampleItem = (source: string, item: string, itemEnd: number, markers: readonly AnyYearMarker[], steps: number): boolean => {
+  if (wordsOf(markers, "example").some((word) => lastWordAt(latinLower(item), word) !== -1)) return true;
+  if (steps === 0 || !opensWithAny(item, wordsOf(markers, "continues"))) return false;
+  const above = itemAbove(source, itemEnd);
+  return above !== undefined && exampleItem(source, above, lineStart(source, itemEnd) - 1, markers, steps - 1);
+};
+
+/** The date's list item opens with a word that carries on the example in the list item just above it. */
+const continuesExample = (date: DateSpan, before: string, source: string, markers: readonly AnyYearMarker[]): boolean => {
+  if (!LIST_ITEM.test(before) || !opensWithAny(before, wordsOf(markers, "continues"))) return false;
+  const above = itemAbove(source, date.offset);
+  return above !== undefined && exampleItem(source, above, lineStart(source, date.offset) - 1, markers, LIST_REACH);
+};
+
+const coversDate = (before: string, dateStart: string, intro: string | undefined, word: string, reach: MarkerReach): boolean => {
+  if (reach === "adjacent") return isAdjacent(latinLower(before), word);
+  if (reach === "near") return lastWordAt(latinLower(before.slice(-(word.length + NEAR_REACH))), word) !== -1;
+  if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
+  if (reach === "continues") return false;
+  const inItem = reach === "example" && LIST_ITEM.test(before) && lastWordAt(latinLower(before), word) !== -1;
+  return inItem || inSentence(before, dateStart, word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
+};
+
 /** The date is a recurring day or a worked example: a marker stands where its reach covers the date. */
 export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[]): boolean => {
   const before = source.slice(lineStart(source, date.offset), date.offset);
   const intro = introOf(source, before, date.offset);
-  return markers.some(({ word: written, reach }) => {
-    const word = latinLower(written);
-    if (word === "") return false;
-    if (reach === "adjacent") return isAdjacent(latinLower(before), word);
-    if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
-    return inSentence(before, source.charAt(date.offset), word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
-  });
+  const covered = markers.some(({ word, reach }) => word !== "" && coversDate(before, source.charAt(date.offset), intro, latinLower(word), reach));
+  return covered || continuesExample(date, before, source, markers);
 };
 
 /** The date opens a period whose other end, just after it, follows a joiner (「4月1日から翌年3月31日」). */