chaffjs 0.21.0 → 0.23.0

package/src/detectors/numeral-opener.ts

@@ -0,0 +1,72 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+
+/**
+ * 数字で始まる文（20 people came.）。読み手は文の頭を大文字で探すので、数字の頭は文の切れ目を見えにくくする。
+ * 数字の後ろが小文字の語のときだけ読む: 「1 Introduction」のような番号の付いた題や「9:00 Opening」のような時刻の行は文ではない。
+ * 年（2026 was a good year.）は綴れないので読まない。
+ */
+
+const OPENING_NUMERAL = /^(?<numeral>\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?%?(?=\s+\p{Ll})/u;
+const SENTENCE_END = /[.!?]["'”’)]*$/u;
+const YEAR = /^[12]\d{3}$/u;
+const HEADING_LINE = /(?:^|\n)#{1,6}\s[^\n]*$/u;
+const CLOSERS = new Set(['"', "'", "”", "’", ")"]);
+const STOP = /[.!?]$/u;
+const WORD_CHAR = /[\p{L}\p{N}.]/u;
+const DIGITS = /^\d+$/u;
+/** 前の文の終わりを探す字数。見出しの行と、終わりの語が入れば足りる。 */
+const LOOKBACK = 300;
+const PLAIN_WORD = /^\p{L}{2,}$/u;
+
+/** 文の頭の数字。年、数字の後ろが小文字の語でないもの、言い終えていない行（見出しのような）は無い。 */
+export const openingNumeral = (text: string): string | undefined => {
+  const trimmed = text.trim();
+  const match = OPENING_NUMERAL.exec(trimmed);
+  const numeral = match?.groups?.["numeral"];
+  if (match === null || numeral === undefined || YEAR.test(numeral) || !SENTENCE_END.test(trimmed)) return undefined;
+  return match[0];
+};
+
+/** text の終わりに続く、belongs を満たす字の並びの始まり（UTF-16 の位置）。 */
+const tailStart = (text: string, belongs: (char: string) => boolean): number =>
+  text.split("").reduceRight((at, char, index) => (at === index + 1 && belongs(char) ? index : at), text.length);
+
+/** 終わりの印（. ! ?）の前の語。点を含めて読む（H.R. は「H.R」）。印で終わっていなければ undefined。 */
+const lastWordBeforeStop = (text: string): string | undefined => {
+  const closed = text.slice(
+    0,
+    tailStart(text, (char) => CLOSERS.has(char)),
+  );
+  if (!STOP.test(closed)) return undefined;
+  const body = closed.slice(0, -1);
+  const start = tailStart(body, (char) => WORD_CHAR.test(char));
+  return start === body.length ? undefined : body.slice(start);
+};
+
+/**
+ * offset の前で、文がほんとうに終わっているか。文書か見出しの直後か、前の文が二字以上の語か数で言い終えているときだけ。
+ * 番号に付ける略した語（vol. 28、H.R. 5376）や、句点の無い行（Lane\n\n2 contains、HTML から移したリンクの切れ目）の後ろの数は文の頭ではない。
+ */
+export const followsSentenceEnd = (source: string, offset: number, labels: ReadonlySet<string>): boolean => {
+  const from = Math.max(0, offset - LOOKBACK);
+  const ended = source.slice(from, offset).trimEnd();
+  if ((ended === "" && from === 0) || HEADING_LINE.test(ended)) return true;
+  const word = lastWordBeforeStop(ended);
+  if (word === undefined) return false;
+  return DIGITS.test(word) || (PLAIN_WORD.test(word) && !labels.has(word.toLowerCase()));
+};
+
+const inside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+const leadingSpace = (sentence: Sentence): number => sentence.text.length - sentence.text.trimStart().length;
+
+export const numeralOpener: Detector = (doc): Finding[] => {
+  const labels = new Set((doc.lexicons["numeral-reference-label"] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return doc.sentences.flatMap((sentence) => {
+    const offset = sentence.span.start + leadingSpace(sentence);
+    if (sentence.embeddedLanguage !== undefined || inside(doc.listSpans, offset)) return [];
+    const numeral = openingNumeral(sentence.text);
+    if (numeral === undefined || !followsSentenceEnd(doc.source, offset, labels)) return [];
+    return [{ rule: "", severity: "warning", line: 0, column: 0, quote: sentence.text.trim(), values: { numeral, offset } }];
+  });
+};

package/src/detectors/ordinal-suffix.ts

@@ -0,0 +1,40 @@
+import type { Detector, Finding, Lexicon } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 数と序数の字が合わない所（3th、22th、11st）。どの数の終わりにどの字が付くかは語彙表 ordinal-suffix が言う。
+
+/** 合わない序数 1 つ。expected はその数に付く字（一つとは限らない）。 */
+export type OrdinalSlip = { readonly offset: number; readonly written: string; readonly number: string; readonly expected: readonly string[] };
+
+/** 数の終わりのうち、語彙表の組にある最も長いものに付く字。 */
+const suffixesFor = (digits: string, suffixes: Lexicon): string[] => {
+  const ending = suffixes
+    .map((entry) => entry.group ?? "")
+    .filter((group) => digits.endsWith(group))
+    .reduce((longest, group) => (group.length > longest.length ? group : longest), "");
+  return suffixes.filter((entry) => (entry.group ?? "") === ending).map((entry) => entry.pattern);
+};
+
+/** 文字列の中の、数と字の合わない序数。語や番号の一部（v1th、0x2nd、1-2th）は読まない。 */
+export const ordinalSlips = (text: string, suffixes: Lexicon): OrdinalSlip[] => {
+  const written = [...new Set(suffixes.map((entry) => entry.pattern))];
+  if (written.length === 0) return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}_.,\\-])(?<n>\\d+(?:,\\d{3})*)(?<suffix>${written.map(escapeRegExp).join("|")})(?![\\p{L}\\p{N}_])`, "gu");
+  return [...text.matchAll(pattern)].flatMap((match) => {
+    const expected = suffixesFor((match.groups?.["n"] ?? "").replaceAll(",", ""), suffixes);
+    return expected.includes(match.groups?.["suffix"] ?? "") ? [] : [{ offset: match.index, written: match[0], number: match.groups?.["n"] ?? "", expected }];
+  });
+};
+
+export const ordinalSuffix: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return ordinalSlips(text, doc.lexicons["ordinal-suffix"] ?? []).map((slip) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, slip.offset, slip.offset + slip.written.length),
+    values: { written: slip.written, expected: `${slip.number}${slip.expected[0] ?? ""}`, offset: slip.offset },
+  }));
+};

package/src/detectors/range-notation.ts

@@ -0,0 +1,76 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 一つの文書で、数の範囲を二通りの記号で書いた所（10〜20 と 10-20、10–20 と 10-20）。どちらが正しいかは決めず、少ないほうを指す。
+// 範囲の記号は語彙表 range-notation が言う。
+
+/** 数の範囲 1 つ。form は二つの数のあいだの記号。 */
+export type WrittenRange = { readonly offset: number; readonly written: string; readonly form: string };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const NUMBER = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+
+/** 範囲のすぐ後ろ（空白一つまで）の単位や語。番号にも使う記号（ハイフン）は、これが続くときだけ範囲と読む。 */
+const UNIT_AFTER = /^\s?[\p{L}%％]/u;
+
+/** 行の頭（見出しや箇条書きの印の後ろ）の「1-2」は節の番号、閉じ括弧のすぐ後ろの「(703) 292-7827」は電話番号。 */
+const LABEL_BEFORE = /(?:^\s*[#>*+|-][\s#>*+|-]*|\)\s?)$/u;
+
+/** 番号の前の札。語彙表の札の語（図、Section）か、頭が大文字の英語の語（NSF）。 */
+const isNumberLabel = (lineBefore: string, labels: readonly string[]): boolean => {
+  const trimmed = lineBefore.trimEnd();
+  if (labels.some((label) => trimmed.endsWith(label))) return true;
+  return /^\p{Lu}/u.test(trimmed.split(/\s/u).at(-1) ?? "");
+};
+
+const halfWidth = (text: string): string => text.replace(/[０-９．]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+/**
+ * 文字列の中の数の範囲。前後にさらに数が続く並び（日付 2026-10-02、電話番号、時刻 10:00、版 1.2-3）は範囲ではない。
+ * 終わりが始まりより小さいもの（郵便番号 100-0001、試合の 3-2）も範囲ではない。ambiguous の記号は、後ろに単位や語が続き、
+ * 前が番号の札（図 2-1、Section 1-2、NSF 13-542）でないときだけ。
+ */
+export const rangesIn = (text: string, marks: readonly string[], ambiguous: readonly string[] = [], labels: readonly string[] = []): WrittenRange[] => {
+  if (marks.length === 0) return [];
+  const joiner = marks
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(
+    `(?<![\\w０-９.．,:：/\\-－–〜～~])(?<from>${NUMBER})\\s?(?<mark>${joiner})\\s?(?<to>${NUMBER})(?![\\w０-９]|[.．,:：/\\-－–〜～~][0-9０-９])`,
+    "gu",
+  );
+  return [...text.matchAll(pattern)].flatMap((match) => {
+    const from = Number(halfWidth(match.groups?.["from"] ?? ""));
+    const to = Number(halfWidth(match.groups?.["to"] ?? ""));
+    const mark = match.groups?.["mark"] ?? "";
+    const unitFollows = UNIT_AFTER.test(text.slice(match.index + match[0].length));
+    const lineBefore = text.slice(text.lastIndexOf("\n", match.index - 1) + 1, match.index);
+    return to > from && !LABEL_BEFORE.test(lineBefore) && (!ambiguous.includes(mark) || (unitFollows && !isNumberLabel(lineBefore, labels)))
+      ? [{ offset: match.index, written: match[0], form: mark }]
+      : [];
+  });
+};
+
+export const rangeNotation: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const entries = doc.lexicons["range-notation"] ?? [];
+  const ranges = rangesIn(
+    text,
+    entries.map((entry) => entry.pattern),
+    entries.filter((entry) => entry.group === "ambiguous").map((entry) => entry.pattern),
+    ["figure-label", "numbered-division", "numbered-label"].flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+  );
+  const minority = formMinority(ranges, options.limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((range) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, range.offset, range.offset + range.written.length),
+    values: { written: range.written, mark: range.form, usual: minority.usual.written, count: minority.odd.length, of: ranges.length, offset: range.offset },
+  }));
+};

package/src/detectors/registry/amount-for-count.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { amountForCount } from "../amount-for-count.ts";
+
+export const detector: Detector = amountForCount;

package/src/detectors/registry/currency-notation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { currencyNotation } from "../currency-notation.ts";
+
+export const detector: Detector = currencyNotation;

package/src/detectors/registry/dangling-opener.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { danglingOpener } from "../dangling-opener.ts";
+
+export const detector: Detector = danglingOpener;

package/src/detectors/registry/ellipsis-consistency.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { ellipsisConsistency } from "../ellipsis.ts";
+
+export const detector: Detector = ellipsisConsistency;

package/src/detectors/registry/footnote-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { footnoteMismatch } from "../footnote-mismatch.ts";
+
+export const detector: Detector = footnoteMismatch;

package/src/detectors/registry/heading-end-punctuation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { headingEndMark } from "../heading-end-mark.ts";
+
+export const detector: Detector = headingEndMark;

package/src/detectors/registry/list-marker.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { listMarkerMix } from "../list-marker.ts";
+
+export const detector: Detector = listMarkerMix;

package/src/detectors/registry/numeral-opener.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { numeralOpener } from "../numeral-opener.ts";
+
+export const detector: Detector = numeralOpener;

package/src/detectors/registry/ordinal-suffix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { ordinalSuffix } from "../ordinal-suffix.ts";
+
+export const detector: Detector = ordinalSuffix;

package/src/detectors/registry/range-notation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { rangeNotation } from "../range-notation.ts";
+
+export const detector: Detector = rangeNotation;

package/src/detectors/registry/relative-pronoun-mix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { relativePronounMix } from "../relative-pronoun-mix.ts";
+
+export const detector: Detector = relativePronounMix;

package/src/detectors/registry/share-over-hundred.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { shareOverHundred } from "../share-over-hundred.ts";
+
+export const detector: Detector = shareOverHundred;

package/src/detectors/registry/step-reference.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepReference } from "../step-reference.ts";
+
+export const detector: Detector = stepReference;

package/src/detectors/registry/table-row-overflow.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { tableRowOverflow } from "../markdown-slip.ts";
+
+export const detector: Detector = tableRowOverflow;

package/src/detectors/registry/toc-heading.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { tocHeading } from "../toc-heading.ts";
+
+export const detector: Detector = tocHeading;

package/src/detectors/registry/unclosed-code-fence.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unclosedCodeFence } from "../markdown-slip.ts";
+
+export const detector: Detector = unclosedCodeFence;

package/src/detectors/registry/unrendered-emphasis.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unrenderedEmphasis } from "../markdown-slip.ts";
+
+export const detector: Detector = unrenderedEmphasis;

package/src/detectors/relative-pronoun-mix.ts

@@ -0,0 +1,79 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { minorityOf } from "./technical-docs.ts";
+import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
+
+/**
+ * 限定の関係節を which で書く所と that で書く所が、一つの文書に混ざっている所（the file which contains / the file that contains）。
+ * どちらが正しいかは決めず、少ないほうを指す。読むのは「名詞 + which|that + 動詞」の、読点を挟まない形だけ。
+ * that の後ろに主語が来る形（the fact that it works）は、関係節か同格の節か語の並びで決まらないので数えない。
+ */
+
+export type RelativeUse = { readonly word: Token; readonly kind: string };
+
+/** 多いほうの書き方が、文書の書き方と言えるだけの数。 */
+const MIN_USUAL = 3;
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** 解析器は三人称の動詞を複数の名詞と読むことがある（the script that checks links の checks）。 */
+const isThirdPersonVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+const isTaggedFiniteVerb = (token: Token | undefined): boolean =>
+  token !== undefined && VERBAL.has(token.pos) && token.features?.["VerbForm"] !== "Part" && token.features?.["VerbForm"] !== "Ger";
+
+/**
+ * 動詞と読める語。名詞と読まれた三人称の動詞は、後ろに動詞が無いときだけ（the idea that results matter の results は主語）。
+ */
+const isFiniteVerb = (token: Token | undefined, next: Token | undefined): boolean =>
+  isTaggedFiniteVerb(token) || (token !== undefined && isThirdPersonVerb(token) && !isTaggedFiniteVerb(next));
+
+const isBaseForm = (verb: Token): boolean => verb.pos === "VERB" && verb.lemma?.toLowerCase() === verb.surface.toLowerCase();
+
+/**
+ * 名詞の後ろの関係節の動詞。原形の動詞は複数の名詞にだけ続く（resources which set）。単数の名詞の後ろの原形は、
+ * 関係節ではなく「どの」の which（tells the command which file to use）。
+ */
+const opensRelative = (noun: Token | undefined, verb: Token | undefined, next: Token | undefined): boolean =>
+  noun?.pos === "NOUN" && verb !== undefined && isFiniteVerb(verb, next) && (!isBaseForm(verb) || noun.features?.["Number"] === "Plur");
+
+/** which / that の後ろの、副詞を飛ばした最初の語（the file which usually stores の stores）。 */
+const verbAfter = (tokens: readonly Token[], at: number): number => {
+  const found = tokens.findIndex((token, index) => index > at && token.pos !== "ADV");
+  return found === -1 ? tokens.length : found;
+};
+
+/** 語彙表の組（which / that）で、tokens の中の限定の関係節の頭。 */
+export const relativeUses = (tokens: readonly Token[], kinds: Lexicon): RelativeUse[] =>
+  tokens.flatMap((word, at) => {
+    const entry = kinds.find((candidate) => candidate.pattern.toLowerCase() === word.surface.toLowerCase());
+    const verb = verbAfter(tokens, at);
+    if (entry?.group === undefined || !opensRelative(tokens[at - 1], tokens[verb], tokens[verb + 1])) return [];
+    return [{ word, kind: entry.group }];
+  });
+
+/** 二通りの書き方のうち少ないほう。多いほうが MIN_USUAL に満たなければ、文書の書き方と言えないので空。 */
+export const oddRelatives = (uses: readonly RelativeUse[], limit: number): { readonly odd: readonly RelativeUse[]; readonly usual: string } => {
+  const kinds = [...new Set(uses.map((use) => use.kind))];
+  const [first, second] = kinds.map((kind) => uses.filter((use) => use.kind === kind));
+  if (kinds.length !== 2 || first === undefined || second === undefined) return { odd: [], usual: "" };
+  const odd = minorityOf(first, second, limit);
+  const usual = odd === first ? second : first;
+  return usual.length < MIN_USUAL ? { odd: [], usual: "" } : { odd, usual: usual[0]?.word.surface.toLowerCase() ?? "" };
+};
+
+export const relativePronounMix: Detector = (doc, options): Finding[] => {
+  const kinds = doc.lexicons["restrictive-relative"] ?? [];
+  const uses = doc.sentences.flatMap((sentence) => {
+    if (sentence.embeddedLanguage !== undefined) return [];
+    const quoted = quotedIn(sentence, QUOTATION_MARKS);
+    return relativeUses(sentence.tokens ?? [], kinds).filter((use) => !isWithinAny(quoted, use.word.span));
+  });
+  const { odd, usual } = oddRelatives(uses, options.limit);
+  return odd.map((use) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: doc.sentences.find((sentence) => sentence.span.start <= use.word.span.start && use.word.span.start < sentence.span.end)?.text.trim() ?? "",
+    values: { word: use.word.surface, usual, count: odd.length, limit: options.limit, offset: use.word.span.start },
+  }));
+};

package/src/detectors/share-over-hundred.ts

@@ -0,0 +1,75 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 集まりの一部の割合なのに 100% を超える百分率（回答者の120%、150% of respondents）。一部は全体を超えない。
+// 集まりの語は語彙表 share-whole、百分率とのあいだの語とその側は share-whole-link、百分率の単位は percent-unit が言う。
+
+export type ShareWords = {
+  readonly wholes: readonly string[];
+  readonly links: readonly { readonly pattern: string; readonly position: "before" | "after" }[];
+  readonly units: readonly string[];
+};
+
+/** 100% を超える一部の割合 1 つ。written は百分率、whole は何の一部か。 */
+export type ShareOverHundred = { readonly offset: number; readonly end: number; readonly written: string; readonly whole: string };
+
+const WHOLE_PERCENT = 100;
+/** 集まりの語が、より長い語の頭でないこと（users_2025、回答者数）。漢字やカタカナが続けば別の語（回答者数は人数で、割合の元ではない）。 */
+const NOT_INSIDE_WORD = "(?![A-Za-z0-9_\\p{Script=Han}\\p{Script=Katakana}])";
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９．]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/** 集まりの語の前後の英字だけを語の切れ目に見る。日本語は語を続けて書く（アンケートでは回答者の、120%の回答者が）。 */
+const wholeNear = (text: string, start: number, end: number, words: ShareWords): string | undefined => {
+  const wholes = alternation(words.wholes);
+  return words.links
+    .map((link) => {
+      const near =
+        link.position === "after"
+          ? new RegExp(`^\\s*${escapeRegExp(link.pattern)}\\s*(?<whole>${wholes})${NOT_INSIDE_WORD}`, "u").exec(text.slice(end))
+          : new RegExp(`(?<![A-Za-z])(?<whole>${wholes})${escapeRegExp(link.pattern)}\\s*$`, "u").exec(text.slice(0, start));
+      return near?.groups?.["whole"];
+    })
+    .find((whole) => whole !== undefined);
+};
+
+/** 文字列の中の、集まりの一部の割合なのに 100% を超える百分率。 */
+export const sharesOverHundred = (text: string, words: ShareWords): ShareOverHundred[] => {
+  if (words.wholes.length === 0 || words.units.length === 0) return [];
+  const percent = new RegExp(`(?<![\\d.,，０-９])(?<value>[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?)\\s?(?:${alternation(words.units)})`, "gu");
+  return [...text.matchAll(percent)].flatMap((match) => {
+    const value = Number(halfWidth(match.groups?.["value"] ?? "").replace(/[,，]/gu, ""));
+    if (value <= WHOLE_PERCENT) return [];
+    const end = match.index + match[0].length;
+    const whole = wholeNear(text, match.index, end, words);
+    return whole === undefined ? [] : [{ offset: match.index, end, written: match[0], whole }];
+  });
+};
+
+const positioned = (doc: ProseDocument): ShareWords["links"] =>
+  (doc.lexicons["share-whole-link"] ?? []).flatMap((entry) => (entry.position === undefined ? [] : [{ pattern: entry.pattern, position: entry.position }]));
+
+export const shareOverHundred: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const words: ShareWords = {
+    wholes: (doc.lexicons["share-whole"] ?? []).map((entry) => entry.pattern),
+    links: positioned(doc),
+    units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  };
+  return sharesOverHundred(text, words).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.end),
+    values: { written: found.written, whole: found.whole, offset: found.offset },
+  }));
+};

package/src/detectors/step-reference.ts

@@ -0,0 +1,83 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 本文が指す手順の番号（「手順5を参照」「see step 5」）が、文書のどの手順にも無い所。
+// 手順は、手順の語（語彙表 step-word）と番号で始まる見出しと、番号付きの箇条書きの項目。手順が一つも無い文書では言わない。
+// 番号のすぐ後ろの語（語彙表 figure-elsewhere の of・in）や前の文書の名前が、ほかの文書の手順だと言えば数えない。
+
+/** 無い手順を指す参照 1 つ。label は書いたままの参照、last は文書の手順の最後の番号。 */
+export type MissingStep = { readonly offset: number; readonly label: string; readonly last: number };
+
+/**
+ * 手順を読むのに要るもの。source は見出しの印（#）を残した文書、prose はコードを覆った本文（位置は source と同じ）。
+ * elsewhere は参照がほかの文書の手順を指すか（参照の始まりと終わりの位置で）。
+ */
+export type StepText = { readonly source: string; readonly prose: string; readonly elsewhere: (start: number, end: number) => boolean };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const LIST_ITEM = /^[ \t]*(?<number>\d{1,3})[.)][ \t]/u;
+const HEADING = /^#{1,6}[ \t]+/u;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+type Mention = { readonly offset: number; readonly label: string; readonly number: number; readonly heading: boolean };
+
+const mentionPattern = (words: readonly string[]): RegExp =>
+  new RegExp(`(?<![A-Za-z])(?:${words.map(escapeRegExp).join("|")})[ \\t\\u3000]?(?<number>[0-9０-９]{1,3})(?![0-9０-９A-Za-z])`, "gu");
+
+const isHeadingAt = (source: string, offset: number): boolean => HEADING.test(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset));
+
+/** 本文の参照（コードを覆った prose から）と、見出しの手順（prose は見出しも覆うので source から）。 */
+const mentionsOf = ({ source, prose }: StepText, words: readonly string[]): Mention[] => {
+  const toMention = (match: RegExpExecArray | RegExpMatchArray, heading: boolean): Mention => ({
+    offset: match.index ?? 0,
+    label: match[0],
+    number: Number(halfWidth(match.groups?.["number"] ?? "")),
+    heading,
+  });
+  const headings = [...source.matchAll(mentionPattern(words))].filter((match) => isHeadingAt(source, match.index)).map((match) => toMention(match, true));
+  const references = [...prose.matchAll(mentionPattern(words))].filter((match) => !isHeadingAt(source, match.index)).map((match) => toMention(match, false));
+  return [...headings, ...references];
+};
+
+const listNumbers = (prose: string): number[] =>
+  prose.split("\n").flatMap((line) => {
+    const number = LIST_ITEM.exec(line)?.groups?.["number"];
+    return number === undefined ? [] : [Number(number)];
+  });
+
+/** 文書のどの手順にも無い番号を指す参照。手順の最後の番号を超えるものだけ（箇条書きが二つあれば、番号はどちらかにある）。 */
+export const missingSteps = (text: StepText, words: readonly string[]): MissingStep[] => {
+  if (words.length === 0) return [];
+  const mentions = mentionsOf(text, words);
+  const steps = [...mentions.filter((mention) => mention.heading).map((mention) => mention.number), ...listNumbers(text.prose)];
+  if (steps.length === 0) return [];
+  const last = Math.max(...steps);
+  return mentions
+    .filter((mention) => !mention.heading && mention.number > last && !text.elsewhere(mention.offset, mention.offset + mention.label.length))
+    .map((mention) => ({ offset: mention.offset, label: mention.label, last }));
+};
+
+/** 番号のすぐ後ろが figure-elsewhere の語か、すぐ前がこの文書でない文書の名前なら、ほかの文書の手順。 */
+const elsewhereOf =
+  (doc: ProseDocument, text: string) =>
+  (start: number, end: number): boolean => {
+    const after = text.slice(end).trimStart();
+    const placed = (doc.lexicons["figure-elsewhere"] ?? []).some((entry) => after.startsWith(`${entry.pattern} `) && /^\s/u.test(text.slice(end)));
+    const named = doc.namedDocument?.(text, start);
+    return placed || (named !== undefined && !named.self);
+  };
+
+export const stepReference: Detector = (doc): Finding[] => {
+  const prose = doc.prose ?? doc.source;
+  const words = (doc.lexicons["step-word"] ?? []).map((entry) => entry.pattern);
+  return missingSteps({ source: doc.source, prose, elsewhere: elsewhereOf(doc, prose) }, words).map((missing) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(prose, missing.offset, missing.offset + missing.label.length),
+    values: { label: missing.label, last: missing.last, offset: missing.offset },
+  }));
+};