chaffjs 0.17.0 → 0.18.0

package/src/detectors/acronym-context.ts

@@ -1,5 +1,5 @@
 import { escapeRegExp } from "../orthography.ts";
-import { ROMAN_NUMERAL } from "./roman-numeral.ts";
+import { ROMAN_NUMERAL, romanRangeOf } from "./roman-numeral.ts";
 import { citationKeySpans } from "./citation-key.ts";
 import { dottedNameSpans } from "./dotted-name.ts";
 import { letterJoinedNameSpans } from "./letter-joined-name.ts";
@@ -24,6 +24,8 @@ export type NotationWords = {
   readonly emphasis: readonly string[];
   /** 番号を後ろに書く、文書の区切りの名前（Part、Section、Title）。 */
   readonly divisions: readonly string[];
+  /** 番号を後ろに書く、点の付いた略した名前（Vol.、No.、FIG.）。 */
+  readonly abbreviatedLabels: readonly string[];
   /** 速記録が大文字で書く発言者の姓の前に置く敬称（Mr.、Mrs.、Madam）。 */
   readonly honorifics: readonly string[];
   /** 大文字で書く姓の前に置く肩書き（Prime Minister、Governor）。後ろに略語も来る（the President NASA memo）ので、名前の形を求める。 */
@@ -44,11 +46,21 @@ const ANY_MERIDIEM = String.raw`[AaPp]\.?[Mm]\.?`;
 const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
 
 /**
- * 区切りの名前のすぐ後ろのローマ数字は番号（Part II、Section VIII、TITLE IV）。名前は語彙表の書き方か、全部大文字。
- * CD や CI のようにローマ数字としても読める略語は、この位置でなければ略語のまま数える。
+ * 区切りの名前や略した名前のすぐ後ろの番号（Part II、Section VIII、TITLE IV、Vol. XLIII、FIG. 3、FIGS. 1A-1C）。名前は語彙表の
+ * 書き方か、全部大文字。ローマ数字は範囲（Part II-IV）も番号。CD や CI のようにローマ数字としても読める略語は、この位置で
+ * なければ略語のまま数える。
  */
 const divisionOf = (words: readonly string[]): string => oneOf(words.flatMap((word) => [word, word.toUpperCase()]));
 
+/** 図や表の番号は短い（FIG. 3、TABLE 12、FIG. 1A）。長い数（FIG. 12345）の前の大文字は略語のまま数える。 */
+const SHORT_NUMBER = String.raw`\d{1,3}[A-Za-z]?`;
+const NUMBER_END = String.raw`(?![\p{L}\p{N}_&])`;
+
+const numberedPatterns = (words: NotationWords): readonly RegExp[] => {
+  const label = String.raw`(?<![\p{L}\p{N}_])${divisionOf([...words.divisions, ...words.abbreviatedLabels])}\s+`;
+  return [new RegExp(`${label}${romanRangeOf(ROMAN_NUMERAL)}${NUMBER_END}`, "gu"), new RegExp(`${label}${SHORT_NUMBER}${NUMBER_END}`, "gu")];
+};
+
 /** 敬称のすぐ後ろの大文字の姓（Mr. HAWLEY、Dr. O'NEIL）。速記録は発言者をこう書き、略語ではない。 */
 const SURNAME_IN_CAPITALS = String.raw`[A-Z]+(?:['’-][A-Z]+)*(?![\p{L}\p{N}_])`;
 
@@ -71,7 +83,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
   new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
   new RegExp(oneOf(words.emphasis), "gu"),
-  new RegExp(String.raw`(?<![\p{L}\p{N}_])${divisionOf(words.divisions)}\s+${ROMAN_NUMERAL}(?![\p{L}\p{N}_&])`, "gu"),
+  ...numberedPatterns(words),
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${oneOf(words.honorifics)}\s+${SURNAME_IN_CAPITALS}`, "gu"),
   ...titledName(oneOf(words.titles)),
 ];

package/src/detectors/ai-phrasing.ts

@@ -0,0 +1,137 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { wordsOf } from "./structure.ts";
+import { MIN_DOCUMENT_LENGTH } from "./signals.ts";
+import { entryIn, entryOpens } from "./lexicon-match.ts";
+import { contrastSentences, type ContrastWords } from "./contrast-frame.ts";
+import { placeholderSpans } from "./placeholder-text.ts";
+import { colonLeadIns } from "./list-lead-in.ts";
+
+// 生成文に多い形。語はどれも言語パッケージの語彙表が持ち、ここは形だけを知る。
+
+const PER = 1000;
+/** 密度は小数 1 桁まで。日本語の 1000 字あたりは 1 と 2 の間で人と生成文が分かれる。 */
+const TENTHS = 10;
+/** 重みの合計を 10 倍した点で比べる（ai-tell と同じ）。重み 0.5 の言い回し 2 つで 10。 */
+const SCORE_SCALE = 10;
+/** 1 つは重なりではない。短い文書では 1 つでも密度が上限を超えるので、数でも止める。 */
+const PILE = 2;
+
+/** 当たった文と語。offset は指摘する位置で、無ければ文の頭。 */
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly offset?: number };
+
+const findingOf = (hit: Hit, values: Readonly<Record<string, number>>): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, ...values, offset: hit.offset ?? hit.sentence.span.start },
+});
+
+/** 1000 語（日本語は 1000 字）あたりの数が上限を超えたら、当たった文をすべて言う。短い文書は密度が暴れるので測らない。 */
+const densityFindings = (doc: ProseDocument, hits: readonly Hit[], limit: number): Finding[] => {
+  const length = wordsOf(doc);
+  if (hits.length < PILE || length < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
+  const density = Math.round((hits.length / length) * PER * TENTHS) / TENTHS;
+  return density <= limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, density, limit }));
+};
+
+const firstIn = (sentence: Sentence, lexicon: Lexicon): LexiconEntry | undefined => lexicon.find((entry) => entryIn(sentence, entry));
+
+const contrastWordsOf = (doc: ProseDocument, frames: Lexicon): ContrastWords => ({
+  frames,
+  leads: doc.lexicons["contrast-lead"] ?? [],
+  turns: doc.lexicons["contrast-turn"] ?? [],
+});
+
+/** 対比の枠（It's not X, it's Y、単なる X ではなく）。1 つなら論点の整理だが、重なると言い回しの癖になる。 */
+export const contrastFraming: Detector = (doc, options): Finding[] => {
+  const words = contrastWordsOf(doc, options.lexicon ?? []);
+  const hits = contrastSentences(doc.sentences, words).map((sentence) => ({
+    sentence,
+    matched: (firstIn(sentence, words.frames) ?? firstIn(sentence, words.leads))?.pattern ?? "",
+  }));
+  return densityFindings(doc, hits, options.limit);
+};
+
+/** 語彙表の語で始まる文。 */
+const openerHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
+  doc.sentences.flatMap((sentence) => {
+    const opener = lexicon.find((entry) => entryOpens(sentence, entry));
+    return opener === undefined ? [] : [{ sentence, matched: opener.pattern }];
+  });
+
+/** 文頭の決まった接ぎ（Moreover、さらに）の密度。話を運ぶ語（However、また）は語彙表に入れない。 */
+export const openerDensity: Detector = (doc, options): Finding[] => densityFindings(doc, openerHits(doc, options.lexicon ?? []), options.limit);
+
+/**
+ * 予告の文頭（重要なのは、Here's the thing）の数。limit は指摘に要る数。
+ * 密度ではなく数で見る。人の記事も長さによらず 1 つ 2 つは書き、生成文は短い記事にも重ねる。
+ */
+export const openerPile: Detector = (doc, options): Finding[] => {
+  const hits = openerHits(doc, options.lexicon ?? []);
+  return hits.length === 0 || hits.length < options.limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, limit: options.limit }));
+};
+
+/** コロンで箇条書きへ渡す文（以下の通りです：）。1 つなら案内だが、節ごとに続くと説明が箇条書きの前置きだけになる。 */
+export const colonLeadIn: Detector = (doc, options): Finding[] => {
+  const hits = colonLeadIns(doc.sentences, doc.lists, doc.listSpans, doc.source).map((sentence) => ({ sentence, matched: sentence.text.trim() }));
+  return densityFindings(doc, hits, options.limit);
+};
+
+const distinct = (lexicon: Lexicon): LexiconEntry[] => [...new Map(lexicon.map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
+
+const weightOf = (entry: LexiconEntry): number => entry.weight ?? 1;
+
+const keyOf = (entry: LexiconEntry): string => entry.pattern.toLowerCase();
+
+type Tally = { readonly score: number; readonly counted: ReadonlySet<string>; readonly hits: readonly Hit[] };
+
+const NOTHING: Tally = { score: 0, counted: new Set(), hits: [] };
+
+/** 1 つの文を足す。重みは、まだ数えていない語のうち最も重いもの。文の語はすべて数えたことにする。 */
+const withSentence = (tally: Tally, sentence: Sentence, inSentence: readonly LexiconEntry[]): Tally => {
+  const fresh = inSentence.filter((entry) => !tally.counted.has(keyOf(entry)));
+  const added = fresh.length === 0 ? 0 : Math.max(...fresh.map(weightOf));
+  const matched = (fresh[0] ?? inSentence[0])?.pattern ?? "";
+  return {
+    score: tally.score + added,
+    counted: new Set([...tally.counted, ...inSentence.map(keyOf)]),
+    hits: [...tally.hits, { sentence, matched }],
+  };
+};
+
+/**
+ * 1 つの文は 1 つの言い回しとして数える（Let me know if you'd like a more detailed breakdown は礼 1 つ）。
+ * 前の文で数えた語は、別の文にあっても数えない（I hope this helps を 2 回書いても礼 1 つ）。
+ */
+const tallyOf = (sentences: readonly Sentence[], entries: readonly LexiconEntry[]): Tally =>
+  sentences.reduce<Tally>((tally, sentence) => {
+    const inSentence = entries.filter((entry) => entryIn(sentence, entry));
+    return inSentence.length === 0 ? tally : withSentence(tally, sentence, inSentence);
+  }, NOTHING);
+
+/**
+ * 会話の返事の名残（As of my last knowledge update、私の知識は）。重みを足した点が上限に届いたら、当たった文をすべて言う。
+ * 名残そのもの（知識の期限、AI としての断り）は 1 つで届き、人も書く礼（I hope this helps）は 2 つ重なって届く。
+ */
+export const assistantResidue: Detector = (doc, options): Finding[] => {
+  const tally = tallyOf(doc.sentences, distinct(options.lexicon ?? []));
+  const score = Math.round(tally.score * SCORE_SCALE);
+  if (tally.hits.length === 0 || score < options.limit) return [];
+  return tally.hits.map((hit) => findingOf(hit, { count: tally.counted.size, density: score, limit: options.limit }));
+};
+
+/** 埋め忘れた雛形の空欄（[Your Name]、【会社名】）。limit は指摘に要る数。 */
+export const unfilledPlaceholder: Detector = (doc, options): Finding[] => {
+  const words = options.lexicon ?? [];
+  const blanks = doc.sentences.flatMap((sentence) =>
+    placeholderSpans(sentence.text, words).map((span) => ({
+      sentence,
+      matched: sentence.text.slice(span.start, span.end),
+      offset: sentence.span.start + span.start,
+    })),
+  );
+  if (blanks.length === 0 || blanks.length < options.limit) return [];
+  return blanks.map((blank) => findingOf(blank, { count: blanks.length, limit: options.limit }));
+};

package/src/detectors/announced-count.ts

@@ -0,0 +1,25 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { announcedCountMismatches, type CountWords } from "../announced-count.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string, position?: "before" | "after"): string[] =>
+  (doc.lexicons[id] ?? []).filter((entry) => position === undefined || entry.position === position).map((entry) => entry.pattern);
+
+const countWordsOf = (doc: ProseDocument): CountWords => ({
+  anchors: patternsOf(doc, "count-anchor"),
+  numbers: patternsOf(doc, "count-number"),
+  counters: patternsOf(doc, "count-counter"),
+  hedgesBefore: patternsOf(doc, "count-hedge", "before"),
+  hedgesAfter: patternsOf(doc, "count-hedge", "after"),
+});
+
+/** 予告の数（以下の3点）と、すぐ下の箇条書きの項目の数が違う。 */
+export const announcedCount: Detector = (doc): Finding[] =>
+  announcedCountMismatches(doc.source, doc.lists, countWordsOf(doc)).map((mismatch) => ({
+    rule: "announced-count-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.offset),
+    values: { phrase: mismatch.phrase, announced: mismatch.announced, listed: mismatch.listed, offset: mismatch.offset },
+  }));

package/src/detectors/broken-link.ts

@@ -0,0 +1,90 @@
+import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+
+/** ページの先頭を指す書き方。見出しが無くても行き先がある。 */
+const PAGE_TOP = new Set(["", "top"]);
+
+/** 名前を比べる形。字と数字だけを小文字で残す。見出しから名前を作る決まりは表示するものごとに違う（空白を - にする・記号を消す）ので、その違いを畳む。 */
+export const anchorKey = (name: string): string => name.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+
+/** 同じ見出しが二つあると、表示するものは二つ目以降に -1、-2 を付ける。 */
+const DUPLICATE_SUFFIX = /-(\d+)$/u;
+
+const decoded = (fragment: string): string => {
+  try {
+    return decodeURIComponent(fragment);
+  } catch {
+    return fragment;
+  }
+};
+
+/** 「&」を and と読んで名前を作るもの（M&IE → m-and-ie）もある。 */
+const namesOf = (text: string): string[] => [...new Set([text, text.replaceAll("&", " and ")])];
+
+const keysOf = (name: string): string[] => [...new Set(namesOf(name).map(anchorKey))];
+
+/**
+ * 文書の中の名前を持つところ。headings は見出しから作る名前の形ごとの数（-1、-2 は見出しだけに付く）。
+ * ids は書き手が付けた名前そのもの。見出しと違って作り方の違いが無いので、書いたとおりに比べる。
+ */
+export type Anchors = { readonly ids: ReadonlySet<string>; readonly headings: ReadonlyMap<string, number> };
+
+export const anchorsOf = (markup: Markup): Anchors => ({
+  ids: markup.ids,
+  headings: markup.headings
+    .flatMap((heading) => keysOf(heading.text))
+    .reduce((counts, key) => counts.set(key, (counts.get(key) ?? 0) + 1), new Map<string, number>()),
+});
+
+/** `#setup-2` は、同じ形の見出しが 3 つ以上あるときだけ行き先がある（二つ目が -1）。 */
+const reachesDuplicate = (fragment: string, headings: ReadonlyMap<string, number>): boolean => {
+  const suffix = DUPLICATE_SUFFIX.exec(fragment);
+  if (suffix === null) return false;
+  return (headings.get(anchorKey(fragment.slice(0, suffix.index))) ?? 0) > Number(suffix[1]);
+};
+
+/** `#…` の行き先が、文書の中の見出しか id を指しているか。 */
+export const reachesAnchor = (destination: string, anchors: Anchors): boolean => {
+  const fragment = decoded(destination.slice(1));
+  if (PAGE_TOP.has(fragment.toLowerCase())) return true;
+  return anchors.ids.has(fragment) || anchors.headings.has(anchorKey(fragment)) || reachesDuplicate(fragment, anchors.headings);
+};
+
+/**
+ * 参照の形で書いたのに名前の定義（`[label]: url`）が無いもの（`[text][label]`、`[text][]`）。字のまま表示される。
+ * 定義があれば CommonMark はリンクにするので、字のまま残った参照の形は定義が無い。英数字のすぐ後ろの括弧（A[i][j]）は配列の添字。
+ */
+const REFERENCE_LIKE = /(?<![\\A-Za-z0-9_\]])\[([^[\]\n]+)\]\[([^[\]\n]*)\]/gu;
+
+/** 数だけの括弧（[1][2]、[3, 4]）は、参照の記法ではなく文献の番号を並べたもの。 */
+const CITATION_NUMBERS = /^[\d\s,，、–-]+$/u;
+
+/** 画像の参照（`![alt][label]`）の頭の印。指摘の範囲に含める。 */
+const IMAGE_MARK = "!";
+
+export const unresolvedReferences = (source: string, markup: Markup): Span[] =>
+  markup.texts.flatMap((text) =>
+    [...source.slice(text.start, text.end).matchAll(REFERENCE_LIKE)]
+      .filter((match) => !CITATION_NUMBERS.test(match[1] ?? ""))
+      .map((match) => ({ start: text.start + match.index, end: text.start + match.index + match[0].length }))
+      .map((span) => (source.charAt(span.start - 1) === IMAGE_MARK ? { start: span.start - 1, end: span.end } : span)),
+  );
+
+const emptyLinks = (doc: ProseDocument, markup: Markup): Finding[] =>
+  markup.links.filter((link) => link.destination.trim() === "").map((link) => findingAt(doc, link, { link: quoteOf(doc.source, link) }, "empty"));
+
+const missingAnchors = (doc: ProseDocument, markup: Markup): Finding[] => {
+  const anchors = anchorsOf(markup);
+  return markup.links
+    .filter((link) => link.destination.startsWith("#") && !reachesAnchor(link.destination, anchors))
+    .map((link) => findingAt(doc, link, { link: quoteOf(doc.source, link), target: link.destination }, "anchor"));
+};
+
+export const brokenLink: Detector = (doc): Finding[] => {
+  const markup = markupOf(doc);
+  if (markup === undefined) return [];
+  const references = unresolvedReferences(doc.source, markup).map((span) => findingAt(doc, span, { link: quoteOf(doc.source, span) }, "reference"));
+  return [...emptyLinks(doc, markup), ...missingAnchors(doc, markup), ...references].toSorted(
+    (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
+  );
+};

package/src/detectors/cited-name.ts

@@ -1,13 +1,14 @@
 import type { StructureNode, Token } from "../plugin.ts";
+import { preOrder } from "../tree-walk.ts";
 
 /** 他の文書を指す参照（民法第709条の第709条）の始まりの位置から、その文書の名前（民法）へ。 */
 export type CitedNames = ReadonlyMap<number, string>;
 
-const namedReferences = (node: StructureNode): (readonly [number, string])[] => {
-  const document = node.attrs["document"];
-  const own: (readonly [number, string])[] = node.kind === "reference" && typeof document === "string" ? [[node.span.start, document]] : [];
-  return [...own, ...node.children.flatMap(namedReferences)];
-};
+const namedReferences = (root: StructureNode): (readonly [number, string])[] =>
+  preOrder(root).flatMap((node) => {
+    const document = node.attrs["document"];
+    return node.kind === "reference" && typeof document === "string" ? [[node.span.start, document] as const] : [];
+  });
 
 export const citedNamesOf = (structure: StructureNode | undefined): CitedNames => new Map(structure === undefined ? [] : namedReferences(structure));
 

package/src/detectors/cited-title.ts

@@ -0,0 +1,96 @@
+import type { Token } from "../plugin.ts";
+import { MINOR_WORDS } from "./heading-case.ts";
+import { columnOf, firstIn, lastIn, type Column } from "./token-column.ts";
+
+// 引用した題名（誌名・論文名・書名）。題名の中の読点は題名を付けた人のもので、書き手が並べかたを選んだものではない。
+
+const isCapitalised = (token: Token): boolean => /^\p{Lu}/u.test(token.surface);
+
+/** 題名の中でつなぐ記号。ハイフン（Low-Inflation）と、副題の前のコロン（Maximum Employment: A Shortfalls Approach）。 */
+const TITLE_JOINERS: ReadonlySet<string> = new Set(["-", ":"]);
+
+/** 題名の中の語。大文字で始まる語と、Title Case でも小文字のままの語（of, and, a）と、つなぐ記号。 */
+const isTitleWord = (token: Token): boolean => isCapitalised(token) || MINOR_WORDS.has(token.surface) || TITLE_JOINERS.has(token.surface);
+
+/** 題名の中の区切り。左は読点もまたぐ（Journal of Money, Credit）。 */
+const inLeftRun = (token: Token): boolean => isTitleWord(token) || token.surface === ",";
+
+/** 2 つの語の間が空白だけか。覆った強調の印（*Journal）や記号を挟めば、題名の語の続きはそこで切れる。 */
+const adjoins = (source: string, left: Token | undefined, right: Token | undefined): boolean =>
+  left === undefined || right === undefined || source.slice(left.span.end, right.span.start).trim() === "";
+
+const LIST_CONJUNCTIONS: ReadonlySet<string> = new Set(["and", "or"]);
+
+const isPhraseWord = (token: Token): boolean => (isCapitalised(token) || MINOR_WORDS.has(token.surface)) && !LIST_CONJUNCTIONS.has(token.surface);
+
+/**
+ * 題名の語の続きの切れ目。左の続きは、題名の語でも読点でもない語か、次の語との間に空白以外を挟む語で切れる。
+ * 右の続きは、題名の語でない語か、前の語との間に空白以外を挟む語で切れる。
+ */
+type Runs = { readonly leftBreak: Column; readonly rightBreak: Column; readonly capital: Column; readonly phrasePair: Column };
+
+const runsOf = (tokens: readonly Token[], source: string): Runs => ({
+  leftBreak: columnOf(tokens, (token, index) => !inLeftRun(token) || !adjoins(source, token, tokens[index + 1])),
+  rightBreak: columnOf(tokens, (token, index) => !isTitleWord(token) || !adjoins(source, tokens[index - 1], token)),
+  capital: columnOf(tokens, isCapitalised),
+  phrasePair: columnOf(tokens, (token, index) => index > 0 && isPhraseWord(token) && isPhraseWord(tokens[index - 1] ?? token)),
+});
+
+/**
+ * and / or の左の、題名の語の続きの頭。最初の大文字の語から。小文字の語から始めると、引用符の中の並び（‘the UK, France and
+ * Spain’）や、論文名のあとの編者の並び（," in Heather Boushey, Ryan Nunn, and Jay Shambaugh, eds.）まで題名と読む。
+ */
+const leftStart = (runs: Runs, at: number): number | undefined => {
+  const stop = lastIn(runs.leftBreak, { start: 0, end: at });
+  const start = firstIn(runs.capital, { start: stop + 1, end: at });
+  return start === -1 ? undefined : start;
+};
+
+/** and / or の右の、題名の語の続きの最後の大文字の語。 */
+const rightEnd = (runs: Runs, at: number, length: number): number | undefined => {
+  const stop = firstIn(runs.rightBreak, { start: at + 1, end: length });
+  const last = lastIn(runs.capital, { start: at + 1, end: stop === -1 ? length : stop });
+  return last === -1 ? undefined : last;
+};
+
+/** 印を探す幅。いちばん長い印（***）と、読点・引用符・空白が収まる。 */
+const MARK_REACH = 8;
+
+/** 題名の最初の語にくっついた開きの印（“ ‘ " ' * _）。 */
+const OPENING = /(?:["'“‘]|\*{1,3}|_{1,3})$/u;
+/** 題名の直後の閉じの印。句読点を挟んでよい（Employment,”）。印の後ろが語なら、語の中の字（TO_CHAR、Madrid’s）。 */
+const CLOSING = /^[,.;:!?]?(?:["'”’]|\*{1,3}|_{1,3})(?![\p{L}\p{N}])/u;
+/** 引用した論文名のあとの読点と閉じる引用符。そのあとの題名は誌名（"Three Lessons," Journal of Money, Credit and Banking）。 */
+const AFTER_QUOTED_TITLE = /,\s*["'”’]\s*$/u;
+/** 誌名のあとは、巻号や頁へ続く読点か文の終わり。述語が続けば（“Done,” Smith, Jones and Brown argued）主語の並び。 */
+const VENUE_END = /^\s*(?:[,;.]|$)/u;
+
+/**
+ * 語の続きに、2 語以上の句があるか（Journal of Money、Their Nature、The Update）。1 語ずつの名前の並び
+ * （‘Paris, Rome and Madrid’）は、引用符の中でも書き手が並べたもの。
+ */
+const holdsPhrase = (runs: Runs, start: number, end: number): boolean => firstIn(runs.phrasePair, { start: start + 1, end: end + 1 }) !== -1;
+
+/**
+ * 文の and / or が、引用した題名の中にあるか。and / or の両隣が Title Case の語の続きで、2 語以上の句を含み、その続きが
+ * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）とき。
+ * 本文の固有名詞の並び（Login.gov, TTS Engineering and USAi）や著者の並びは囲まれていないので、題名と読まない。
+ * 文を一度だけ読み、どの位置の問いにも続きを読み直さずに答える。
+ */
+export const citedTitles = (tokens: readonly Token[], source: string): ((at: number) => boolean) => {
+  const runs = runsOf(tokens, source);
+  return (at) => {
+    const start = leftStart(runs, at);
+    const end = rightEnd(runs, at, tokens.length);
+    const first = start === undefined ? undefined : tokens[start];
+    const last = end === undefined ? undefined : tokens[end];
+    if (start === undefined || end === undefined || first === undefined || last === undefined) return false;
+    if (!holdsPhrase(runs, start, end)) return false;
+    const before = source.slice(Math.max(0, first.span.start - MARK_REACH), first.span.start);
+    const after = source.slice(last.span.end, last.span.end + MARK_REACH);
+    return (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+  };
+};
+
+/** at の and / or が、引用した題名の中にあるか。 */
+export const inCitedTitle = (tokens: readonly Token[], at: number, source: string): boolean => citedTitles(tokens, source)(at);

package/src/detectors/concrete-evidence.ts

@@ -1,4 +1,5 @@
 import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+import { preOrder } from "../tree-walk.ts";
 
 /**
  * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
@@ -27,5 +28,5 @@ export const startsWithin = (section: Span, spans: readonly Span[]): boolean =>
 /** 構造の木が読んだ参照（第3条・Section VI）・数量・日付。どれも読み手が確かめに行ける具体物。 */
 const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "date"]);
 
-export const evidenceSpans = (node: StructureNode | undefined): Span[] =>
-  node === undefined ? [] : [...(EVIDENCE.has(node.kind) ? [node.span] : []), ...node.children.flatMap((child) => evidenceSpans(child))];
+export const evidenceSpans = (root: StructureNode | undefined): Span[] =>
+  root === undefined ? [] : preOrder(root).flatMap((node) => (EVIDENCE.has(node.kind) ? [node.span] : []));

package/src/detectors/contrast-frame.ts

@@ -0,0 +1,54 @@
+import type { Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { comparableText, comparableWords, entryIn, entryOpens, entryRanges } from "./lexicon-match.ts";
+
+/**
+ * 対比の枠の語。frames は 1 つで枠になる語（not only、だけでなく）。
+ * leads は打ち消し（it's not、単なる）で、turns（it's、but、ではなく）が後ろに来たときだけ枠になる。同じ文の後ろか、次の文の頭。
+ * 打ち消しの頭に立つ返しの語（It's not ready. It's not tested. の 2 つ目の It's）は返しではなく、次の打ち消し。
+ */
+export type ContrastWords = { readonly frames: Lexicon; readonly leads: Lexicon; readonly turns: Lexicon };
+
+const lowered = (entry: LexiconEntry): string => comparableWords(entry.pattern);
+
+type Range = { readonly start: number; readonly end: number };
+
+/** 返しの語が、それより長い打ち消しの頭にあるか（It's not の It's）。同じ長さなら返しのまま（ではなく は打ち消しでも返しでもある）。 */
+const opensLongerLead = (found: Range, leads: readonly Range[]): boolean => leads.some((lead) => lead.start === found.start && lead.end > found.end);
+
+const answersAfter = (leadRange: Range, turns: readonly Range[], leads: readonly Range[]): boolean =>
+  turns.some((found) => found.start >= leadRange.end && !opensLongerLead(found, leads));
+
+/** 文字列の中で word が現れる範囲、左から順に。 */
+const rangesOf = (text: string, word: string): Range[] =>
+  [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => ({ start: match.index, end: match.index + word.length }));
+
+/** 品詞が無ければ位置を語で言えないので、空白をまとめた文字列の位置で比べる。 */
+const textTurnAfter = (sentence: Sentence, lead: LexiconEntry, words: ContrastWords): boolean => {
+  const text = comparableText(sentence);
+  const leads = words.leads.flatMap((entry) => rangesOf(text, lowered(entry)));
+  const turns = words.turns.flatMap((entry) => rangesOf(text, lowered(entry)));
+  return rangesOf(text, lowered(lead)).some((range) => answersAfter(range, turns, leads));
+};
+
+/** 打ち消しの語より後ろに、返しの語があるか。打ち消しそのもの（it's not の it's）と、次の打ち消しの頭は返しに数えない。 */
+const turnAfter = (sentence: Sentence, lead: LexiconEntry, words: ContrastWords): boolean => {
+  if (sentence.tokens === undefined || lead.tokens === undefined) return textTurnAfter(sentence, lead, words);
+  const leads = words.leads.flatMap((entry) => entryRanges(sentence, entry));
+  const turns = words.turns.flatMap((entry) => entryRanges(sentence, entry));
+  return entryRanges(sentence, lead).some((range) => answersAfter(range, turns, leads));
+};
+
+/** 次の文が返しの語で始まり、それ自体が打ち消しで始まっていないか。 */
+const nextTurns = (next: Sentence | undefined, words: ContrastWords): boolean =>
+  next !== undefined && words.turns.some((turn) => entryOpens(next, turn)) && !words.leads.some((lead) => entryOpens(next, lead));
+
+const answered = (sentence: Sentence, next: Sentence | undefined, words: ContrastWords): boolean =>
+  words.leads.some((lead) => entryIn(sentence, lead) && (turnAfter(sentence, lead, words) || nextTurns(next, words)));
+
+/**
+ * 対比の枠で書いた文。「X ではなく Y」「It's not X. It's Y.」の形で、打ち消した側の文を返す。
+ * 2 文にまたがる枠も 1 つと数える。返しの文は数えない。
+ */
+export const contrastSentences = (sentences: readonly Sentence[], words: ContrastWords): Sentence[] =>
+  sentences.filter((sentence, index) => words.frames.some((frame) => entryIn(sentence, frame)) || answered(sentence, sentences[index + 1], words));

package/src/detectors/custom.ts

@@ -0,0 +1,89 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+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";
+
+// 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.
+
+type Hit = { readonly sentence: Sentence; readonly offset: number; readonly matched: string; readonly preferred: string };
+
+const findingOf = (hit: Hit): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, preferred: hit.preferred, offset: hit.sentence.span.start + hit.offset },
+});
+
+/**
+ * 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.
+ */
+const readAsWritten = (sentence: Sentence): JoinedView =>
+  joinedView(
+    sentence.text,
+    (sentence.wrapBreaks ?? []).map((span) => ({ start: span.start - sentence.span.start, end: span.end - sentence.span.start })),
+  );
+
+/** A match at [start, end) of the joined text, as a hit at the sentence's own position. */
+const hitAt = (sentence: Sentence, view: JoinedView, start: number, end: number, preferred: string): Hit => ({
+  sentence,
+  offset: view.toSource({ start, end }).start,
+  matched: view.text.slice(start, end),
+  preferred,
+});
+
+/** source[start, end) with the line breaks inside words taken out: the text of a run of tokens as the reader reads it. */
+const withoutBreaks = (source: string, start: number, end: number, breaks: readonly Span[]): string =>
+  breaks
+    .filter((span) => span.start >= start && span.end <= end)
+    .toReversed()
+    .reduce((text, span) => `${text.slice(0, span.start - start)}${text.slice(span.end - start)}`, source.slice(start, end));
+
+/** words: each spelling to avoid, outside the spelling to use (「ユーザ」 inside 「ユーザー」 is not reported). */
+export const customWords: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "words") return [];
+  return doc.sentences.flatMap((sentence) => {
+    const view = readAsWritten(sentence);
+    return spec.words.flatMap((pair) =>
+      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => findingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
+    );
+  });
+};
+
+/** pattern: each match of the team's regular expression in a sentence. Checked when chaff.yaml was read, and run with a time limit. */
+export const customPattern: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "pattern") return [];
+  const views = doc.sentences.map(readAsWritten);
+  const matches = boundedMatches(
+    spec.pattern,
+    spec.flags,
+    views.map((view) => view.text),
+  );
+  return doc.sentences.flatMap((sentence, at) => {
+    const view = views[at];
+    if (view === undefined) return [];
+    return (matches[at] ?? []).map((match) => findingOf(hitAt(sentence, view, match.index, match.index + match.text.length, "")));
+  });
+};
+
+/** tokens: each run of tokens that meets the conditions in order, quoted from its first token to its last, line breaks inside words taken out. */
+export const customTokens: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "tokens") return [];
+  return doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokenRuns(tokens, spec.tokens).flatMap(([first, last]) => {
+      const [start, end] = [tokens[first]?.span.start, tokens[last]?.span.end];
+      if (start === undefined || end === undefined) return [];
+      return [
+        findingOf({ sentence, offset: start - sentence.span.start, matched: withoutBreaks(doc.source, start, end, sentence.wrapBreaks ?? []), preferred: "" }),
+      ];
+    });
+  });
+};

package/src/detectors/dangling-figure.ts

@@ -0,0 +1,22 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { danglingFigures, type LabelWords } from "../figure-references.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const labelWordsOf = (doc: ProseDocument): LabelWords => ({
+  labels: (doc.lexicons["figure-label"] ?? []).map((entry) => ({ word: entry.pattern, kind: entry.instead_of ?? entry.pattern })),
+  elsewhere: patternsOf(doc, "figure-elsewhere"),
+  counters: patternsOf(doc, "count-counter"),
+});
+
+/** 本文が指す図・表・付録の番号が、キャプションにも見出しにも無い。 */
+export const danglingFigure: Detector = (doc): Finding[] =>
+  danglingFigures(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links).map((dangling) => ({
+    rule: "dangling-figure-reference",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, dangling.offset),
+    values: { label: dangling.label, offset: dangling.offset },
+  }));