chaffjs 0.19.0 → 0.21.0

package/src/detectors/date-format.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { dateGroups, dateMinority, datesIn, type DateMinority } from "../date-format.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/**
+ * 一つの文書で、日付を二通り以上の書き方で書いた所（2026-10-02 と 2026年10月2日、Oct 2, 2026 と 10/2/2026）。少ないほうを指す。
+ * 行の頭の日付（予定表の行）と文の中の日付は別に比べる。月の名前は語彙表 month-name、元号は calendar-era が言う。コードの中の日付は読まない。
+ */
+const findingsOf = (doc: ProseDocument, minority: DateMinority): Finding[] =>
+  minority.odd.map((date) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, date.offset),
+    values: { written: date.written, example: minority.majority.written, count: minority.count, total: minority.total, offset: date.offset },
+  }));
+
+export const dateFormat: Detector = (doc, options): Finding[] => {
+  const words = {
+    months: (doc.lexicons["month-name"] ?? []).map((entry) => entry.pattern),
+    eras: (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern),
+  };
+  const text = doc.prose ?? doc.source;
+  return dateGroups(text, datesIn(text, words)).flatMap((group) => {
+    const minority = dateMinority(group, options.limit);
+    return minority === undefined ? [] : findingsOf(doc, minority);
+  });
+};

package/src/detectors/date-year.ts

@@ -0,0 +1,91 @@
+// A date written without its year where the document's other dates carry one, or where the year cannot be read off
+// because the document's dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** A date as the tree reads it: "2026-10-14" with its year, "10-14" without. */
+export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type YearGap = { readonly point: DatePoint; readonly kind: "minority" | "boundary"; readonly dated: number };
+
+/** The words just before a date that give its year in words (その年の, 同年, 毎年): the date has a year, or means every year. */
+export const YEAR_REFERENCE_LEXICON = "year-reference";
+
+const FULL = /^\d{4}-(\d{2})-\d{2}$/u;
+const MONTH_DAY = /^(\d{2})-\d{2}$/u;
+
+/** How far before a date a year word may stand (「同年12月」「その年の12月」). */
+const YEAR_WORD_REACH = 6;
+
+/** The months at the end and the start of a year: a date in one, written beside a dated one in the other, could be either year. */
+const YEAR_END = new Set([11, 12]);
+const YEAR_START = new Set([1, 2]);
+
+const monthOf = (pattern: RegExp, value: string): number | undefined => {
+  const month = pattern.exec(value)?.[1];
+  return month === undefined ? undefined : Number(month);
+};
+
+const sideOf = (month: number | undefined): "end" | "start" | undefined => {
+  if (month === undefined) return undefined;
+  if (YEAR_END.has(month)) return "end";
+  return YEAR_START.has(month) ? "start" : undefined;
+};
+
+/** A yearless date at one turn of the year while a dated one sits at the other: 1月15日 beside 2026年12月1日. */
+const crossesYear = (point: DatePoint, datedSides: ReadonlySet<string>): boolean => {
+  const side = sideOf(monthOf(MONTH_DAY, point.value));
+  return side !== undefined && datedSides.has(side === "end" ? "start" : "end");
+};
+
+const lineStart = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const hasYearWord = (point: DatePoint, source: string, yearWords: readonly string[]): boolean => {
+  const before = source.slice(Math.max(lineStart(source, point.offset), point.offset - YEAR_WORD_REACH), point.offset);
+  return yearWords.some((word) => word !== "" && before.includes(word));
+};
+
+/**
+ * A yearless date whose year the text gives anyway: a year word just before it (「同年12月28日」「その年の12月31日」), or,
+ * earlier on the same line, a date with a year or with a year word (「2026年9月25日から10月7日まで」「その年の1月1日から12月31日まで」).
+ */
+const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly string[]): boolean => {
+  const start = lineStart(source, point.offset);
+  return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+};
+
+/**
+ * The yearless dates to report. Where most dates carry a year (at least two, and more than the yearless ones), every yearless
+ * one is the odd one out. Otherwise writing the year once is the document's style, and only a date across the turn of a
+ * year is reported. A date whose year the text gives in words or earlier on its line is never reported, nor counted.
+ */
+export const yearGaps = (points: readonly DatePoint[], source = "", yearWords: readonly string[] = []): YearGap[] => {
+  const dated = points.filter((point) => FULL.test(point.value));
+  const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
+  const yearless = points.filter((point) => MONTH_DAY.test(point.value) && !yearGiven(point, anchors, source, yearWords));
+  const minority = dated.length >= 2 && yearless.length < dated.length;
+  const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
+  return yearless.flatMap((point): YearGap[] => {
+    if (minority) return [{ point, kind: "minority", dated: dated.length }];
+    return crossesYear(point, datedSides) ? [{ point, kind: "boundary", dated: dated.length }] : [];
+  });
+};
+
+export const datePoints = (tree: StructureNode): DatePoint[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+const yearWordsOf = (doc: ProseDocument): string[] => (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry) => entry.pattern);
+
+export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc)).map((gap) => ({
+        rule: "date-without-year",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, gap.point.offset),
+        ...(gap.kind === "boundary" ? { variant: "boundary" } : {}),
+        values: { date: doc.source.slice(gap.point.offset, gap.point.end), count: gap.dated, offset: gap.point.offset },
+      }));

package/src/detectors/defined-term-form.ts

@@ -0,0 +1,200 @@
+// A defined term used later in another form, and a long name used again after its short name was defined. Pure. The
+// definitions come from the document's structure tree (以下「甲」という, ("Seller")); which words may stand in a long
+// name is read from the tokens' parts of speech.
+import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../structure/definition-use.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+
+const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+
+const finding = (doc: ProseDocument, rule: string, offset: number, variant: string, values: Readonly<Record<string, string | number>>): Finding => ({
+  rule,
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+  variant,
+});
+
+const OPENING_QUOTES = new Set(["「", "『", '"', "“"]);
+const CLOSING_QUOTES = new Set(["」", "』", '"', "”"]);
+/** A quoted term right before these is defined again (「X」とは, "X" means), which duplicate-definition reads. */
+const DEFINING_AFTER = /^(?:とは|という|\s+(?:means|shall mean|refers to|has the meaning))/u;
+/** The ending a use may carry past the term: a plural or a possessive (Services, Service's). */
+const WORD_ENDING = /^(?:e?s|['’]s?)/u;
+
+/** The first definition of each term, with the spans of all its definitions. */
+const firstDefinitions = (terms: readonly DefinedTerm[]): { readonly term: DefinedTerm; readonly spans: readonly Span[] }[] => {
+  const groups = new Map<string, { term: DefinedTerm; spans: Span[] }>();
+  terms.forEach((term) => {
+    const group = groups.get(term.term);
+    if (group === undefined) groups.set(term.term, { term, spans: [term.span] });
+    else group.spans.push(term.span);
+  });
+  return [...groups.values()];
+};
+
+/** A use of the term set in quotes again after its definition: 「本サービス」 where 本サービス was defined. */
+export const quotedUses = (source: string, term: string, uses: readonly number[], definedAt: number): number[] =>
+  uses.filter((offset) => {
+    const after = offset + term.length + (WORD_ENDING.exec(source.slice(offset + term.length, offset + term.length + 2))?.[0].length ?? 0);
+    return (
+      offset > definedAt &&
+      OPENING_QUOTES.has(source.charAt(offset - 1)) &&
+      CLOSING_QUOTES.has(source.charAt(after)) &&
+      !DEFINING_AFTER.test(source.slice(after + 1, after + 20))
+    );
+  });
+
+const UPPER_START = /^\p{Lu}/u;
+
+/**
+ * The uses of a capitalised term written in lower case ("services" where "Services" is defined), when they are the fewer
+ * and at most limit: a document that mostly writes it in lower case uses the word in its ordinary sense on purpose.
+ */
+export const lowerCaseUses = (source: string, term: string, uses: readonly number[], definedAt: number, limit: number): number[] => {
+  if (!UPPER_START.test(term) || term.toLowerCase() === term) return [];
+  const later = uses.filter((offset) => offset > definedAt);
+  const lower = later.filter((offset) => source.charAt(offset) === term.charAt(0).toLowerCase() && !isSentenceStart(source, offset));
+  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0));
+  return lower.length > 0 && lower.length < capital.length && lower.length <= limit ? lower : [];
+};
+
+/** How far back a sentence's start is looked for: past a few spaces to the mark before them. */
+const LOOK_BACK = 40;
+const SENTENCE_END = new Set([".", "!", "?", ":"]);
+
+/** A sentence's first word is capitalised whatever it is, so only a lower-case use inside a sentence counts. */
+const isSentenceStart = (source: string, offset: number): boolean => {
+  const before = source.slice(Math.max(0, offset - LOOK_BACK), offset);
+  const text = before.trimEnd();
+  return (offset < LOOK_BACK && text === "") || before.slice(text.length).includes("\n") || SENTENCE_END.has(text.at(-1) ?? "");
+};
+
+/** Where the sentence holding the definition ends: a use inside it ("Customer" means the party named "Customer") belongs to the definition. */
+const definingSentenceEnd = (doc: ProseDocument, definition: Span): number =>
+  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end)?.span.end ?? definition.end;
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** A word used as a verb ("you input"), not the defined thing ("the Input"): a different word that shares the spelling. */
+const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
+  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
+  const at = tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end);
+  const token = tokens[at];
+  if (token === undefined) return false;
+  // After a subject pronoun the word is its verb (you input), whatever the tagger says; after a possessive (your input) it is a noun.
+  const before = tokens[at - 1];
+  const afterSubject = before?.pos === "PRON" && before.features?.["Poss"] !== "Yes";
+  return VERBAL.has(token.pos) || afterSubject;
+};
+
+export const definedTermForm: Detector = (doc, options): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const texts = bodyOf(doc);
+  return firstDefinitions(definedTerms(doc.structure)).flatMap(({ term, spans }) => {
+    const uses = usesOf(term.term, texts, spans, "loose");
+    const definingEnd = definingSentenceEnd(doc, term.span);
+    const quoted = quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
+      finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
+    );
+    const nounUses = uses.filter((offset) => !isVerbAt(doc, offset));
+    const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
+      finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
+    );
+    return [...quoted, ...lower];
+  });
+};
+
+/** The words a long name is made of: nouns and names (株式会社 みなと 製作所, Acme Corporation), and the marks inside one. */
+const NAME_PARTS = new Set(["NOUN", "PROPN", "NUM"]);
+const NAME_MARKS = new Set(["・", "&", "＆", ".", ","]);
+/** A long name shorter than this (法律, Customer) is an ordinary word, used in its own sense again. */
+const MIN_NAME_CHARS = 4;
+/** In English a long name has two words or more (Acme Corporation); one capitalised word is the term's own kind of word. */
+const MIN_NAME_WORDS = 2;
+const LATIN = /\p{Script=Latin}/u;
+
+const isNamePart = (token: Token): boolean => NAME_PARTS.has(token.pos) || NAME_MARKS.has(token.surface);
+
+/** The long name written right before an inline definition: the run of name words that ends at its opening bracket. */
+export const nameBefore = (sentence: Sentence, bracket: number): string | undefined => {
+  const tokens = (sentence.tokens ?? []).filter((token) => token.span.end <= bracket);
+  const firstOfRun = tokens.findLastIndex((token) => !isNamePart(token)) + 1;
+  if (isModifier(tokens[firstOfRun - 1])) return undefined;
+  const run = tokens.slice(firstOfRun).filter((token, index, all) => index > 0 || !NAME_MARKS.has(token.surface) || all.length === 1);
+  const first = run[0];
+  const end = run.at(-1);
+  if (first === undefined || end === undefined || bracket - end.span.end > 1) return undefined;
+  const name = withoutTrailingMarks(sentence.text.slice(first.span.start - sentence.span.start, end.span.end - sentence.span.start));
+  const words = name.split(/\s+/u).length;
+  return [...name].length < MIN_NAME_CHARS || (LATIN.test(name) && words < MIN_NAME_WORDS) ? undefined : name;
+};
+
+/**
+ * A word that narrows the name before it: an article, an adjective, a verb, or の (妊娠中の女性従業員, the Beta Preview, 本利用規約).
+ * The words then name a kind of thing the definition picks out, not one party, and are used in their own sense again.
+ */
+const MODIFIERS = new Set(["DET", "ADJ", "VERB", "AUX"]);
+const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || token.surface === "の");
+
+const TRAILING_MARKS = new Set([",", ".", " "]);
+
+const withoutTrailingMarks = (text: string): string => {
+  const chars = [...text];
+  return chars.slice(0, chars.findLastIndex((char) => !TRAILING_MARKS.has(char)) + 1).join("");
+};
+
+/** Where the inline definition's bracket opens: （以下「甲」という。） or ("Seller"). */
+const bracketBefore = (source: string, definition: Span): number => {
+  const before = source.slice(Math.max(0, definition.start - 2), definition.start + 1);
+  const at = Math.max(before.lastIndexOf("（"), before.lastIndexOf("("));
+  return at === -1 ? -1 : Math.max(0, definition.start - 2) + at;
+};
+
+export type RepeatedName = { readonly offset: number; readonly name: string; readonly term: string; readonly line: number };
+
+/** A line that holds the short name too (甲 株式会社みなと) or little else than the long name: a signature block names both. */
+const isNameLine = (source: string, offset: number, name: string, term: string): boolean => {
+  const start = source.lastIndexOf("\n", offset - 1) + 1;
+  const end = source.indexOf("\n", offset);
+  const line = source.slice(start, end === -1 ? source.length : end).trim();
+  const SLACK = 12;
+  return line.includes(term) || [...line].length <= [...name].length + SLACK;
+};
+
+/** A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+const standsAlone = (source: string, offset: number, name: string): boolean =>
+  !WORD_CHAR.test(source.charAt(offset - 1)) && !WORD_CHAR.test(source.charAt(offset + name.length));
+
+/**
+ * Each use of a long name after the definition gave it a short name, outside a signature line. A name that is itself a
+ * defined term (during each Subscription Term ("Permitted Use")) is a clause's last words, not the thing being named.
+ */
+export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[]): RepeatedName[] => {
+  const defined = new Set(terms.map((term) => term.term));
+  return terms
+    .filter((term) => term.inline)
+    .flatMap((term) => {
+      const bracket = bracketBefore(doc.source, term.span);
+      const sentence = doc.sentences.find((candidate) => candidate.span.start <= bracket && bracket < candidate.span.end);
+      const name = sentence === undefined || bracket === -1 ? undefined : nameBefore(sentence, bracket);
+      if (name === undefined || name === term.term || term.term.includes(name) || defined.has(name)) return [];
+      const pattern = new RegExp(escapeRegExp(name), "gu");
+      return doc.sentences
+        .filter((later) => later.span.start > term.span.end)
+        .flatMap((later) => [...later.text.matchAll(pattern)].map((match) => later.span.start + match.index))
+        .filter((offset) => standsAlone(doc.source, offset, name) && !isNameLine(doc.source, offset, name, term.term))
+        .map((offset) => ({ offset, name, term: term.term, line: term.line }));
+    });
+};
+
+export const definedNameRepeated: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : repeatedNames(doc, definedTerms(doc.structure)).map((repeated) =>
+        finding(doc, "defined-name-repeated", repeated.offset, "name", { name: repeated.name, term: repeated.term, line: repeated.line }),
+      );

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",
+    }));
+};