chaffjs 0.19.0 → 0.20.0

package/src/detectors/derived-numbers.ts

@@ -0,0 +1,191 @@
+import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
+import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
+import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
+const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
+  ["duration-day", "day"],
+  ["duration-week", "week"],
+  ["duration-month", "month"],
+  ["duration-year", "year"],
+];
+
+type Quantity = Span & { readonly amount: number; readonly unit: string };
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const positioned = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
+  (doc.lexicons[id] ?? []).filter((entry) => (entry.position ?? "before") === position).map((entry) => entry.pattern.toLowerCase());
+
+/** 数のすぐ後ろ（空白一つまで）に書いた単位まで。木の数量は単位の前で終わることがある（30 years の 30）。 */
+const endWithUnit = (source: string, end: number, unit: string): number => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  return unit !== "" && source.startsWith(unit, end + gap) ? end + gap + unit.length : end;
+};
+
+const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
+  inDocumentOrder(tree).flatMap((node): Quantity[] => {
+    if (node.kind !== "quantity") return [];
+    const unit = String(node.attrs["unit"] ?? "");
+    return [{ start: node.span.start, end: endWithUnit(source, node.span.end, unit), amount: Number(node.attrs["value"]), unit: unit.normalize("NFKC") }];
+  });
+
+const datesOf = (tree: StructureNode): DatedValue[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+const NEAR = 12;
+
+const textBefore = (doc: ProseDocument, span: Span): string =>
+  doc.source
+    .slice(Math.max(0, span.start - NEAR), span.start)
+    .toLowerCase()
+    .trimEnd();
+const textAfter = (doc: ProseDocument, span: Span): string =>
+  doc.source
+    .slice(span.end, span.end + NEAR)
+    .toLowerCase()
+    .trimStart();
+
+/** 「約3か月」「3か月程度」"about 3 months": 目安の期間は足し算に使わない。 */
+const isApproximate = (doc: ProseDocument, span: Span): boolean =>
+  positioned(doc, "approximate-marker", "before").some((word) => textBefore(doc, span).endsWith(word)) ||
+  positioned(doc, "approximate-marker", "after").some((word) => textAfter(doc, span).startsWith(word));
+
+const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[]): Duration[] =>
+  quantities.flatMap((quantity) => {
+    const unit = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC") === quantity.unit))?.[1];
+    return unit === undefined || isApproximate(doc, quantity) ? [] : [{ start: quantity.start, end: quantity.end, amount: quantity.amount, unit }];
+  });
+
+const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
+
+/** 始まり + 期間 ≠ 終わり。 */
+export const durationMismatch: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const durations = durationsOf(doc, quantitiesOf(doc.structure, doc.source));
+  return durationMismatches(sentencesOf(doc), datesOf(doc.structure), durations).map((mismatch) => ({
+    rule: "duration-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.end.start),
+    values: {
+      start: doc.source.slice(mismatch.start.start, mismatch.start.end),
+      duration: doc.source.slice(mismatch.duration.start, mismatch.duration.end),
+      end: doc.source.slice(mismatch.end.start, mismatch.end.end),
+      expected: mismatch.expected,
+      offset: mismatch.end.start,
+    },
+  }));
+};
+
+/** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */
+const BARE_YEAR = /(?<![\p{N}.,])[12]\d{3}(?!\p{N})/gu;
+
+const yearsOf = (doc: ProseDocument, tree: StructureNode, quantities: readonly Quantity[]): Year[] => {
+  const dated = datesOf(tree).flatMap((date): Year[] => {
+    const year = yearOf(date.value);
+    return year === undefined ? [] : [{ start: date.start, end: date.end, year }];
+  });
+  const taken = spanIndex([...datesOf(tree), ...quantities]);
+  const bare = [...doc.source.matchAll(BARE_YEAR)].flatMap((match): Year[] => {
+    const span = { start: match.index, end: match.index + match[0].length };
+    return overlapsAny(taken, span) ? [] : [{ ...span, year: Number(match[0]) }];
+  });
+  return [...dated, ...bare];
+};
+
+const LATIN = /^[a-z ]+$/iu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** 語彙表の語が書かれた所。英字の語は語の切れ目でだけ。 */
+const wordsOf = (doc: ProseDocument, id: string): OriginWord[] =>
+  patternsOf(doc, id).flatMap((pattern) => {
+    const lower = doc.source.toLowerCase();
+    const needle = pattern.toLowerCase();
+    const found: OriginWord[] = [];
+    for (let at = lower.indexOf(needle); at !== -1; at = lower.indexOf(needle, at + needle.length)) {
+      const bounded = !LATIN.test(pattern) || (!WORD_CHAR.test(lower.charAt(at - 1)) && !WORD_CHAR.test(lower.charAt(at + needle.length)));
+      if (bounded) found.push({ start: at, end: at + needle.length, pattern });
+    }
+    return found;
+  });
+
+/** 年齢: 単位が年齢の語（歳）か、年齢の印（aged、years old）の付いた数量。 */
+const isAge = (doc: ProseDocument, quantity: Quantity): boolean =>
+  patternsOf(doc, "age-unit").some((unit) => unit.normalize("NFKC") === quantity.unit) ||
+  positioned(doc, "age-marker", "before").some((word) => textBefore(doc, quantity).endsWith(word)) ||
+  positioned(doc, "age-marker", "after").some((word) => textAfter(doc, quantity).startsWith(word));
+
+const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] =>
+  quantities.filter((quantity) => !isAge(doc, quantity) && patternsOf(doc, "elapsed-unit").some((unit) => unit.normalize("NFKC") === quantity.unit));
+
+/** 「aged 45」の 45: 英語の木は単位の無い数を読まないので、年齢の印のすぐ後ろの数を読む。 */
+const AGE_NUMBER = /^\s*(\d{1,3})(?!\d)/u;
+
+const markedAges = (doc: ProseDocument): Elapsed[] =>
+  positioned(doc, "age-marker", "before").flatMap((marker) =>
+    wordsOf(doc, "age-marker")
+      .filter((word) => word.pattern.toLowerCase() === marker)
+      .flatMap((word): Elapsed[] => {
+        const number = AGE_NUMBER.exec(doc.source.slice(word.end));
+        if (number === null) return [];
+        const start = word.end + number[0].length - (number[1] ?? "").length;
+        return [{ start, end: word.end + number[0].length, amount: Number(number[1]) }];
+      }),
+  );
+
+/** 文書の日付の年: 日付だけの段落か「更新日：」の段落（date-stamp）の、最初の日付。 */
+const referenceYear = (doc: ProseDocument, tree: StructureNode): number | undefined => {
+  const dates = datesOf(tree);
+  const candidates = stampCandidates(
+    doc.source,
+    doc.paragraphs.map((paragraph) => paragraph.span),
+    dates,
+  );
+  const stamps = dateStampIndexes(candidates, patternsOf(doc, "date-stamp-label"));
+  const paragraph = doc.paragraphs.find((_, index) => stamps.has(index));
+  const date = paragraph === undefined ? undefined : dates.find((candidate) => candidate.start >= paragraph.span.start && candidate.end <= paragraph.span.end);
+  return date === undefined ? undefined : yearOf(date.value);
+};
+
+/** 起点の年から数えた年数が、文書の日付と合わない。 */
+export const elapsedYearsMismatch: Detector = (doc): Finding[] => {
+  const tree = doc.structure;
+  const reference = tree === undefined ? undefined : referenceYear(doc, tree);
+  if (tree === undefined || reference === undefined) return [];
+  const quantities = quantitiesOf(tree, doc.source);
+  const quantityAges = quantities.filter((quantity) => isAge(doc, quantity));
+  const taken = spanIndex(quantityAges);
+  const ages = [...quantityAges, ...markedAges(doc).filter((age) => !overlapsAny(taken, age))].toSorted((left, right) => left.start - right.start);
+  const input = {
+    source: doc.source,
+    sentences: sentencesOf(doc),
+    years: yearsOf(doc, tree, quantities),
+    foundings: wordsOf(doc, "elapsed-origin"),
+    births: wordsOf(doc, "birth-origin"),
+    elapsed: elapsedOf(doc, quantities),
+    ages,
+    links: patternsOf(doc, "elapsed-link"),
+    reference,
+  };
+  return elapsedMismatches(input).map((mismatch) => ({
+    rule: "elapsed-years-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.elapsed.start),
+    values: {
+      written: doc.source.slice(mismatch.elapsed.start, mismatch.elapsed.end),
+      origin: doc.source.slice(mismatch.origin.start, mismatch.origin.end),
+      reference,
+      expected: mismatch.expected,
+      offset: mismatch.elapsed.start,
+    },
+  }));
+};

package/src/detectors/document-shape.ts

@@ -0,0 +1,107 @@
+// The shape of a document's top: whether the lead says anything the title does not, and whether a title or heading
+// runs too long to scan. Pure; both read only the sections, paragraphs and tokens chaff has already built.
+import { newContentMorphemes } from "./content-morphemes.ts";
+import { trigrams } from "./heading-overlap.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+import type { Detector, Finding, LengthUnit, MarkupHeading, Paragraph, ProseDocument, Section } from "../plugin.ts";
+
+/** A title shorter than this many character trigrams matches any lead by chance. */
+const MIN_TITLE_GRAMS = 4;
+
+/** The share of the title's trigrams the lead must repeat before its new words are counted: a lead on another subject is not an echo. */
+const MIN_ECHO_PERCENT = 50;
+
+const PERCENT = 100;
+
+/** The document's title: its first top-level heading, when it has words. */
+export const titleSectionOf = (doc: ProseDocument): Section | undefined => doc.sections.find((section) => section.depth === 1 && section.heading.trim() !== "");
+
+/** The paragraph right under the title, with nothing but blank lines between them. A list, a table or an image first is not a lead. */
+export const leadParagraphOf = (doc: ProseDocument, title: Section): Paragraph | undefined => {
+  const first = doc.paragraphs.find((paragraph) => paragraph.span.start >= title.span.start && paragraph.span.start < title.span.end);
+  if (first === undefined || first.sentences.length === 0) return undefined;
+  return doc.source.slice(title.span.start, first.span.start).trim() === "" ? first : undefined;
+};
+
+/** How much of the title the lead repeats: the share of the title's character trigrams found in the lead, in percent. */
+export const echoPercent = (title: string, lead: string): number => {
+  const titleGrams = trigrams(title);
+  if (titleGrams.size < MIN_TITLE_GRAMS) return 0;
+  const leadGrams = trigrams(lead);
+  return Math.round(([...titleGrams].filter((gram) => leadGrams.has(gram)).length / titleGrams.size) * PERCENT);
+};
+
+type Lead = { readonly title: Section; readonly lead: Paragraph; readonly fresh: number; readonly echo: number };
+
+const leadOf = (doc: ProseDocument): Lead | undefined => {
+  const title = titleSectionOf(doc);
+  const lead = title === undefined ? undefined : leadParagraphOf(doc, title);
+  if (title === undefined || lead === undefined || title.headingTokens === undefined) return undefined;
+  const leadTokens = lead.sentences.flatMap((sentence) => sentence.tokens ?? []);
+  const leadText = lead.sentences.map((sentence) => sentence.text).join(" ");
+  return { title, lead, fresh: newContentMorphemes(title.headingTokens, leadTokens), echo: echoPercent(title.heading, leadText) };
+};
+
+/**
+ * The lead restates the title: it repeats most of the title and adds fewer than `limit` content words of its own.
+ * Both must hold: a lead that adds little but is about something else (a date, a byline) is not a restatement.
+ */
+export const noLead: Detector = (doc, options): Finding[] => {
+  const found = leadOf(doc);
+  if (found === undefined || found.echo < MIN_ECHO_PERCENT || found.fresh >= options.limit) return [];
+  const first = found.lead.sentences[0];
+  return [
+    {
+      rule: "no-lead",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first?.text.trim() ?? "",
+      values: { title: found.title.heading, count: found.fresh, echo: found.echo, limit: options.limit, offset: first?.span.start ?? found.lead.span.start },
+    },
+  ];
+};
+
+/** A run of Latin letters and digits inside Japanese: a word, read at about the width of two characters. */
+const LATIN_WORD = /[A-Za-z0-9][A-Za-z0-9._\-/@+#]*/gu;
+const LATIN_WORD_CHARS = 2;
+
+/** Inline Markdown left in a heading's text (`code`, **bold**, _emphasis_), which the reader does not see. */
+const INLINE_MARKS = /[`*_]/gu;
+
+/** A heading's length in the document's unit: words, or characters with each Latin word counted as two. */
+export const headingLength = (heading: string, unit: LengthUnit): number => {
+  const plain = heading.replace(INLINE_MARKS, "");
+  if (unit === "word") return plain.split(/\s+/u).filter((word) => /[\p{L}\p{N}]/u.test(word)).length;
+  const latinWords = [...plain.matchAll(LATIN_WORD)];
+  const rest = plain.replace(LATIN_WORD, "").replace(/\s+/gu, "");
+  return [...rest].length + latinWords.length * LATIN_WORD_CHARS;
+};
+
+/**
+ * A heading that holds a sentence end followed by more text: a description pasted into the title line, not a name written
+ * too long. A paragraph above a ---- rule is already left out by writtenHeadings.
+ */
+const SENTENCES_INSIDE = /[。．！？](?=\s*\S)|\p{Ll}{2}[.!?]["'”’)]?\s+["'“‘(]?\p{Lu}/u;
+
+export const isParagraphHeading = (heading: string): boolean => SENTENCES_INSIDE.test(heading.trim());
+
+/** The heading's words without a number label at its head (Chapter 2, 1.), from the section the heading opens. */
+const unlabeledOf = (doc: ProseDocument, heading: MarkupHeading): string =>
+  doc.sections.find((section) => section.span.start === heading.end)?.unlabeledHeading ?? heading.text;
+
+/** Each title or heading longer than the limit. The first top-level heading is the title; every other is a heading. */
+export const titleLength: Detector = (doc, options): Finding[] => {
+  const headings = writtenHeadings(doc);
+  const title = headings.find((heading) => heading.depth === 1);
+  return headings
+    .map((heading) => ({ heading, words: unlabeledOf(doc, heading) }))
+    .filter(({ words }) => !isParagraphHeading(words))
+    .map(({ heading, words }) => ({ heading, count: headingLength(words, doc.lengthUnit) }))
+    .filter(({ count }) => count > options.limit)
+    .map(({ heading, count }) => ({
+      ...findingAt(doc, heading, { heading: heading.text.trim(), count, limit: options.limit }, heading === title ? "title" : undefined),
+      rule: "title-length",
+      severity: "info",
+    }));
+};

package/src/detectors/emoji-heading.ts

@@ -0,0 +1,17 @@
+import type { Detector, Finding, MarkupHeading, ProseDocument } from "../plugin.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+
+/** A character drawn as an emoji: one that is by default, a pictograph asking for it (U+FE0F), or a keycap (1️⃣). ™, → and anything asking for text (U+FE0E) are text. */
+const EMOJI = new RegExp(String.raw`\p{Emoji_Presentation}(?!\u{FE0E})|\p{Extended_Pictographic}\u{FE0F}|[0-9#*]\u{FE0F}?\u{20E3}`, "u");
+
+export const hasEmoji = (text: string): boolean => EMOJI.test(text);
+
+/** The headings, in document order, whose words carry an emoji. */
+export const emojiHeadings = (doc: ProseDocument): MarkupHeading[] => writtenHeadings(doc).filter((heading) => hasEmoji(heading.text));
+
+/** A count, not a density: one decorated heading is a choice, a row of them is a template. */
+export const emojiHeading: Detector = (doc, options): Finding[] => {
+  const marked = emojiHeadings(doc);
+  if (marked.length === 0 || marked.length < options.limit) return [];
+  return marked.map((heading) => findingAt(doc, heading, { heading: heading.text, count: marked.length, limit: options.limit }));
+};

package/src/detectors/fact-consistency.ts

@@ -0,0 +1,54 @@
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { labelledFacts, type AttributePhrase, type FactWords } from "../facts/labelled-facts.ts";
+import { tableFacts } from "../facts/table-facts.ts";
+import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
+import { scopeConflicts, summaryConflicts, type FactConflict } from "../facts/fact-conflicts.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+export const factWordsOf = (doc: ProseDocument): FactWords => ({
+  separators: patternsOf(doc, "fact-separator"),
+  valueEnds: patternsOf(doc, "fact-value-end"),
+  determiners: patternsOf(doc, "fact-label-drop"),
+  vague: patternsOf(doc, "fact-label-vague"),
+  attributes: (doc.lexicons["fact-attribute"] ?? []).map((entry): AttributePhrase => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
+});
+
+const factsByDocument = new WeakMap<ProseDocument, readonly ScopedFact[]>();
+
+const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  const facts = [...labelledFacts(doc.source, values, factWordsOf(doc)), ...tableFacts(doc.source, values)];
+  return scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading"));
+};
+
+/** 文書の名前付きの値。二つの rule が読むので、文書ごとに一度だけ読む。 */
+const factsOf = (doc: ProseDocument): readonly ScopedFact[] => {
+  const cached = factsByDocument.get(doc);
+  if (cached !== undefined) return cached;
+  const facts = doc.structure === undefined ? [] : readFacts(doc, doc.structure);
+  factsByDocument.set(doc, facts);
+  return facts;
+};
+
+const shown = (doc: ProseDocument, value: FactValue): string => doc.source.slice(value.start, value.end);
+
+const findingOf =
+  (rule: string, doc: ProseDocument) =>
+  (conflict: FactConflict): Finding => ({
+    rule,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, conflict.fact.value.start),
+    values: { label: conflict.fact.label, value: shown(doc, conflict.fact.value), other: shown(doc, conflict.other), offset: conflict.fact.value.start },
+  });
+
+/** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
+export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
+
+/** 冒頭や要約の値が、本文の同じ名前の値と違う。 */
+export const summaryFactMismatch: Detector = (doc): Finding[] => summaryConflicts(factsOf(doc)).map(findingOf("summary-fact-mismatch", doc));

package/src/detectors/figure-order.ts

@@ -0,0 +1,81 @@
+// Figures and tables referred to out of numeric order, first referred to only a section after they appear, or never
+// referred to while their siblings are. Pure; the figure words come from the language's figure-label lexicon.
+import { figureMentions, type Mention as FigureMention } from "../figure-references.ts";
+import { labelWordsOf } from "./dangling-figure.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+export type FigureOrderSlip =
+  | { readonly variant: "order"; readonly offset: number; readonly label: string; readonly after: string }
+  | { readonly variant: "late"; readonly offset: number; readonly label: string }
+  | { readonly variant: "unreferenced"; readonly offset: number; readonly label: string };
+
+/** The number as a tuple to compare (3 → [3], 3.2 → [3, 2]); undefined for letters and kanji numerals, which are not ordered here. */
+export const numberOf = (mention: FigureMention): readonly number[] | undefined => {
+  const number = mention.key.slice(mention.key.indexOf("\u0000") + 1).replace(/[-－]/gu, ".");
+  return /^\d+(?:\.\d+)*$/u.test(number) ? number.split(".").map(Number) : undefined;
+};
+
+const compare = (left: readonly number[], right: readonly number[]): number => {
+  const differs = left.findIndex((part, index) => part !== (right[index] ?? -1));
+  if (differs === -1) return left.length - right.length;
+  return (left[differs] ?? 0) - (right[differs] ?? -1);
+};
+
+/** The first mention of each figure, by its key, in document order. */
+const firstByKey = (mentions: readonly FigureMention[]): Map<string, FigureMention> =>
+  mentions.reduce((first, mention) => (first.has(mention.key) ? first : first.set(mention.key, mention)), new Map<string, FigureMention>());
+
+/** Each first reference whose number is lower than one of its kind first referred to earlier. */
+export const outOfOrder = (references: readonly FigureMention[]): FigureOrderSlip[] => {
+  const highest = new Map<string, { readonly number: readonly number[]; readonly written: string }>();
+  return [...firstByKey(references).values()].flatMap((mention): FigureOrderSlip[] => {
+    const number = numberOf(mention);
+    if (number === undefined) return [];
+    const before = highest.get(mention.kind);
+    if (before !== undefined && compare(number, before.number) < 0)
+      return [{ variant: "order", offset: mention.start, label: mention.written, after: before.written }];
+    highest.set(mention.kind, { number, written: mention.written });
+    return [];
+  });
+};
+
+/**
+ * Each captioned figure first referred to only after a heading that follows its caption, and each captioned figure never
+ * referred to, when the document refers to another of its kind (so it is the kind of document that refers to its figures).
+ */
+export const placementSlips = (
+  captions: readonly FigureMention[],
+  references: readonly FigureMention[],
+  headingStarts: readonly number[],
+  inTextKinds: ReadonlySet<string>,
+): FigureOrderSlip[] => {
+  const referredKinds = new Set(references.map((mention) => mention.kind));
+  const firstReference = firstByKey(references);
+  const firstCaptions = [...firstByKey(captions).values()].filter((mention) => inTextKinds.has(mention.kind));
+  return firstCaptions.flatMap((caption): FigureOrderSlip[] => {
+    const first = firstReference.get(caption.key);
+    if (first === undefined) return referredKinds.has(caption.kind) ? [{ variant: "unreferenced", offset: caption.start, label: caption.written }] : [];
+    const headingBetween = headingStarts.some((start) => caption.end < start && start < first.start);
+    return headingBetween ? [{ variant: "late", offset: first.start, label: first.written }] : [];
+  });
+};
+
+export const figureOrderSlips = (doc: ProseDocument): FigureOrderSlip[] => {
+  const { captions, references } = figureMentions(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links);
+  const headingStarts = (doc.markup?.headings ?? []).map((heading) => heading.start);
+  const inTextKinds = new Set((doc.lexicons["figure-in-text"] ?? []).map((entry) => entry.pattern));
+  const slips = [...outOfOrder(references), ...placementSlips(captions, references, headingStarts, inTextKinds)];
+  return slips.toSorted((left, right) => left.offset - right.offset);
+};
+
+export const figureOrder: Detector = (doc): Finding[] =>
+  figureOrderSlips(doc).map((slip) => ({
+    rule: "figure-reference-order",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { label: slip.label, after: slip.variant === "order" ? slip.after : "", offset: slip.offset },
+    variant: slip.variant,
+  }));

package/src/detectors/heading-numbering.ts

@@ -0,0 +1,38 @@
+import type { Detector, Finding, LexiconEntry } from "../plugin.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+import { numberingMinorities, numberingStyleOf, UNNUMBERED, type NumberingMinority, type NumberLabel } from "../heading-numbering.ts";
+
+const labelsOf = (entries: readonly LexiconEntry[]): NumberLabel[] =>
+  entries.map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
+
+/** 前後の見出しの語のあとに続いてよい区切り（「付録: 用語」「Appendix A」）。 */
+const AFTER_MATTER = /^[\s:：、]/u;
+
+/** 番号を付けない前後の見出し（目次・参考文献・付録 A）か。言葉全体が語彙表の語か、語彙表の語に区切りが続くとき。 */
+const isFrontOrBackMatter = (text: string, words: readonly string[]): boolean => {
+  const lowered = text.trim().toLowerCase();
+  return words.some((word) => lowered === word || (lowered.startsWith(word) && AFTER_MATTER.test(lowered.slice(word.length))));
+};
+
+const variantOf = (minority: NumberingMinority): string => {
+  if (minority.kind === "style") return "style";
+  return minority.majority === UNNUMBERED ? "numbered" : "unnumbered";
+};
+
+/**
+ * 兄弟の見出し（同じ親の下の同じ深さ）で、番号を付けたものと付けないもの、番号の書き方（1. と 1）と 第1章）が混ざっている所。
+ * 少ないほうを指す。どの語が番号を持つか（第1章、Chapter 1）は語彙表 heading-number-label、番号を付けない前後の見出しは unnumbered-heading が言う。
+ */
+export const headingNumbering: Detector = (doc): Finding[] => {
+  const headings = writtenHeadings(doc);
+  const labels = labelsOf(doc.lexicons["heading-number-label"] ?? []);
+  const matter = (doc.lexicons["unnumbered-heading"] ?? []).map((entry) => entry.pattern.toLowerCase());
+  const styles = headings.map((heading) => numberingStyleOf(heading.text, labels));
+  const read = headings.map((heading, at) => ({ depth: heading.depth, style: styles[at] ?? UNNUMBERED, skipped: isFrontOrBackMatter(heading.text, matter) }));
+  return numberingMinorities(read).flatMap((minority) => {
+    const heading = headings[minority.at];
+    if (heading === undefined) return [];
+    const values = { heading: heading.text.trim(), count: minority.count, example: headings[minority.example]?.text.trim() ?? "" };
+    return [findingAt(doc, heading, values, variantOf(minority))];
+  });
+};