chaffjs 0.16.0 → 0.18.0

package/src/detectors/agreement-slip.ts

@@ -0,0 +1,191 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { isPartOfLongerWord } from "./doubled-word.ts";
+
+/**
+ * 語の形が合っていない（a significant changes / one of the most important feature / Your can check）。
+ * 書き換えで片方の語だけ直した跡。解析器の読みが一通りに決まる形だけを数える。語はすべてアダプタの語彙表から来る。
+ */
+
+export type AgreementLists = {
+  /** 一つを数える限定詞（a / each）。 */
+  readonly singular: Lexicon;
+  /** 複数を数える限定詞と句（these / one of the）。 */
+  readonly plural: Lexicon;
+  /** 単数と複数が同じ綴りの名詞（series / data）。 */
+  readonly invariant: ReadonlySet<string>;
+  /** 単数の限定詞で複数を数える形容詞（a few days）。 */
+  readonly count: ReadonlySet<string>;
+  /** 名詞の前にしか立たない所有の語（your / their）。 */
+  readonly possessive: ReadonlySet<string>;
+  /** 名詞にならない be / have の形（is / has）。 */
+  readonly finite: ReadonlySet<string>;
+  /** 単数で書く所を複数で書いた句（ones of the most）。 */
+  readonly misnumbered: Lexicon;
+};
+
+export type Slip = { readonly variant: "number" | "possessive"; readonly first: Token; readonly last: Token; readonly word: string };
+
+const SPACE_ONLY = /^\s+$/u;
+const UPPER_START = /^\p{Lu}/u;
+const LETTER = /\p{L}/u;
+const LOWER = /\p{Ll}/u;
+/** 名詞句を閉じる記号。読点・括弧の始まり・ハイフンは、名詞を重ねた語（a sales, marketing and support team）の途中にも立つ。 */
+const CLOSING_MARK = new Set([".", ";", ":", "?", "!", ")"]);
+/**
+ * 名詞の後ろに来れば、名詞句はそこで終わっている品詞。名詞・形容詞・接続詞・所有の印は、名詞を重ねた語の途中。
+ * 動詞は、名詞にならない be / have の形（is / has）だけ。解析器は複数の名詞の後ろの名詞を動詞と読む（a sales team の team が VBP）。
+ */
+const PHRASE_END = new Set(["AUX", "ADP", "SCONJ", "PRON", "DET", "ADV"]);
+const PREDICATE_TAIL = new Set(["DET", "ADJ", "PRON", "NUM"]);
+
+const lower = (token: Token): string => token.surface.toLowerCase();
+
+const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part" || token.features?.["VerbForm"] === "Ger";
+
+const isArticle = (token: Token): boolean => token.features?.["PronType"] === "Art";
+
+const isPlural = (token: Token): boolean => token.features?.["Number"] === "Plur";
+
+/** 名詞の後ろの語で、名詞句が終わるか。分詞（a data driven approach）も名詞を重ねた語の途中。 */
+export const endsNounPhrase = (next: Token | undefined, finite: ReadonlySet<string>): boolean => {
+  if (next === undefined || finite.has(lower(next))) return true;
+  return next.pos === "PUNCT" ? CLOSING_MARK.has(next.surface) : PHRASE_END.has(next.pos);
+};
+
+const wordsOf = (entry: Lexicon[number]): readonly string[] =>
+  entry.tokens === undefined ? entry.pattern.toLowerCase().split(/\s+/u) : entry.tokens.map((token) => token.surface.toLowerCase());
+
+/** tokens の at 語目から始まる語彙表の句の長さ。無ければ 0。 */
+const phraseAt = (tokens: readonly Token[], at: number, phrases: Lexicon): number => {
+  const matched = phrases.map(wordsOf).find((words) => words.every((word, k) => tokens[at + k]?.surface.toLowerCase() === word));
+  return matched?.length ?? 0;
+};
+
+/** first から last まで、語のあいだが空白だけ。コードの印やリンクを挟めば別々の語。 */
+const joinedBySpace = (source: string, tokens: readonly Token[]): boolean =>
+  tokens.slice(1).every((token, k) => SPACE_ONLY.test(source.slice(tokens[k]?.span.end ?? token.span.start, token.span.start)));
+
+const opensSentence = (tokens: readonly Token[], at: number): boolean => !tokens.slice(0, at).some((token) => LETTER.test(token.surface));
+
+/** 文の途中の大文字の限定詞は、名前の一部（Plan A users）。 */
+const isNamePart = (tokens: readonly Token[], at: number): boolean => UPPER_START.test(tokens[at]?.surface ?? "") && !opensSentence(tokens, at);
+
+const isModifier = (token: Token): boolean => token.pos === "ADJ" || token.pos === "ADV" || (token.pos === "VERB" && isParticiple(token));
+
+/** 限定詞の後ろの修飾語。数の形容詞（a few days）が挟まれば、単数の限定詞でも複数を数えるので undefined。 */
+const modifiersAfter = (tokens: readonly Token[], from: number, count: ReadonlySet<string>): readonly Token[] | undefined => {
+  const end = tokens.findIndex((token, index) => index >= from && !isModifier(token));
+  const modifiers = tokens.slice(from, end === -1 ? tokens.length : end);
+  return modifiers.some((token) => count.has(lower(token))) ? undefined : modifiers;
+};
+
+const isGuessed = (token: Token): boolean => token.features?.["Guess"] === "Yes";
+
+/** 単数と複数が同じ綴りの語、複数と付いても原形が同じ語（lens）、解析器が形から当てた語（stimuli）は、どちらの数とも決まらない。 */
+const hasOneNumber = (noun: Token, invariant: ReadonlySet<string>): boolean =>
+  !invariant.has(lower(noun)) && !isGuessed(noun) && !(isPlural(noun) && noun.lemma?.toLowerCase() === lower(noun));
+
+const isCommonNoun = (token: Token | undefined): token is Token => token?.pos === "NOUN" && !UPPER_START.test(token.surface);
+
+type Determiner = { readonly head: Token; readonly length: number; readonly plural: boolean };
+
+const determinerAt = (tokens: readonly Token[], at: number, lists: AgreementLists): Determiner | undefined => {
+  const head = tokens[at];
+  const plural = phraseAt(tokens, at, lists.plural);
+  const singular = phraseAt(tokens, at, lists.singular);
+  if (head === undefined || plural + singular === 0) return undefined;
+  return plural > 0 ? { head, length: plural, plural: true } : { head, length: singular, plural: false };
+};
+
+/**
+ * 冠詞と句でない限定詞（this / these）は代名詞にもなる。This results in a loss の results は動詞なので、
+ * 形容詞を挟んだ名詞（this new rules）だけを数える。
+ */
+const standsAlone = (determiner: Determiner): boolean => determiner.length === 1 && !isArticle(determiner.head);
+
+const readsAsDeterminer = (determiner: Determiner, modifiers: readonly Token[]): boolean =>
+  !standsAlone(determiner) || modifiers.some((token) => token.pos === "ADJ");
+
+const mayBeNoun = (token: Token): boolean => token.features?.["AlsoNoun"] === "Yes" || isGuessed(token);
+
+/**
+ * 名詞が動詞にも読め（works）、その前に名詞句の頭になれる語があれば、限定詞と名詞ではなく主語と動詞かもしれない。
+ * an individual works（individual は名詞にもなる）/ Those responsible report to the board（those は代名詞にもなる）。
+ * 後ろが is / has なら、名詞は動詞ではない（these key result is）。
+ */
+const mayBeVerb = (determiner: Determiner, modifiers: readonly Token[], noun: Token, next: Token | undefined, finite: ReadonlySet<string>): boolean =>
+  noun.features?.["AlsoVerb"] === "Yes" && !(next !== undefined && finite.has(lower(next))) && (standsAlone(determiner) || modifiers.some(mayBeNoun));
+
+const numberSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const determiner = determinerAt(tokens, at, lists);
+  if (determiner === undefined || isNamePart(tokens, at)) return undefined;
+  const modifiers = modifiersAfter(tokens, at + determiner.length, lists.count);
+  if (modifiers === undefined || !readsAsDeterminer(determiner, modifiers)) return undefined;
+  const nounAt = at + determiner.length + modifiers.length;
+  const noun = tokens[nounAt];
+  if (!isCommonNoun(noun) || !hasOneNumber(noun, lists.invariant) || isPlural(noun) === determiner.plural) return undefined;
+  if (mayBeVerb(determiner, modifiers, noun, tokens[nounAt + 1], lists.finite)) return undefined;
+  const span = tokens.slice(at, nounAt + 1);
+  if (!endsNounPhrase(tokens[nounAt + 1], lists.finite) || !joinedBySpace(source, span) || isPartOfLongerWord(source, determiner.head, noun)) return undefined;
+  return slipOf("number", source, determiner.head, noun);
+};
+
+const slipOf = (variant: Slip["variant"], source: string, first: Token, last: Token): Slip => ({
+  variant,
+  first,
+  last,
+  word: source.slice(first.span.start, last.span.end).replace(/\s+/gu, " "),
+});
+
+const isBaseVerb = (token: Token | undefined): boolean => token?.pos === "VERB" && token.features?.["VerbForm"] === undefined;
+
+/** 所有の語の直後の be（their is）か、助動詞 + 動詞の原形（Your can check）。名詞にもなる助動詞（your will）は動詞が続くときだけ。 */
+const possessiveSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const [possessive, verb] = [tokens[at], tokens[at + 1]];
+  if (possessive === undefined || verb === undefined || !lists.possessive.has(lower(possessive))) return undefined;
+  // 大文字だけの語は略語（Your AM = account manager）。
+  const verbal = LOWER.test(verb.surface) && (lists.finite.has(lower(verb)) || (verb.pos === "AUX" && isBaseVerb(tokens[at + 2])));
+  if (!verbal || !joinedBySpace(source, [possessive, verb]) || isPartOfLongerWord(source, possessive, verb)) return undefined;
+  return slipOf("possessive", source, possessive, verb);
+};
+
+/** ones of the most。前に限定詞・形容詞・代名詞があれば、ones は代名詞（the ones of the most use）。 */
+const misnumberedAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
+  const span = tokens.slice(at, at + phraseAt(tokens, at, lists.misnumbered));
+  const [first, last, previous] = [span[0], span.at(-1), tokens[at - 1]];
+  if (first === undefined || last === undefined || (previous !== undefined && PREDICATE_TAIL.has(previous.pos))) return undefined;
+  return joinedBySpace(source, span) ? slipOf("number", source, first, last) : undefined;
+};
+
+export const agreementIn = (source: string, tokens: readonly Token[], lists: AgreementLists): Slip[] =>
+  tokens.flatMap((_, at) => {
+    const slip = numberSlipAt(source, tokens, at, lists) ?? possessiveSlipAt(source, tokens, at, lists) ?? misnumberedAt(source, tokens, at, lists);
+    return slip === undefined ? [] : [slip];
+  });
+
+const setOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
+
+const listsOf = (lexicons: Readonly<Record<string, Lexicon>>): AgreementLists => ({
+  singular: lexicons["singular-determiner"] ?? [],
+  plural: lexicons["plural-determiner"] ?? [],
+  invariant: setOf(lexicons["invariant-noun"]),
+  count: setOf(lexicons["count-adjective"]),
+  possessive: setOf(lexicons["dependent-possessive"]),
+  finite: setOf(lexicons["finite-auxiliary"]),
+  misnumbered: lexicons["misnumbered-phrase"] ?? [],
+});
+
+export const agreementSlip: Detector = (doc): Finding[] => {
+  const lists = listsOf(doc.lexicons);
+  return doc.sentences.flatMap((sentence) =>
+    agreementIn(doc.source, sentence.tokens ?? [], lists).map((slip): Finding => ({
+      rule: "agreement-slip",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { word: slip.word, offset: slip.first.span.start },
+      variant: slip.variant,
+    })),
+  );
+};

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/content-morphemes.ts

@@ -0,0 +1,19 @@
+// What a sentence adds to a heading, counted in content morphemes: words that stand by themselves and name something.
+// Pure; heading-echo measures a language written without spaces with it, where a character count says nothing
+// (「会社に勤めています」 carries two new words, 「について説明します」 one, in the same nine characters).
+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";
+
+/** 原形で照らす（変えました → 変える）。原形の無い語は書いた形で。 */
+const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** The sentence's content morphemes whose base form is not one of the heading's content morphemes, every occurrence counted. */
+export const newContentMorphemes = (heading: readonly Token[], sentence: readonly Token[]): number => {
+  const said = new Set(heading.filter(isContent).map(baseForm));
+  return sentence.filter((token) => isContent(token) && !said.has(baseForm(token))).length;
+};