chaffjs 0.28.0 → 0.29.0

package/src/detectors/undefined-term.ts

@@ -0,0 +1,103 @@
+// A term written as a defined term but defined nowhere: 本成果物 in a contract that defines 本業務 and 本契約 but no
+// 本成果物. The document's own prefix for its defined terms (本, 本件: the language package's defined-term-prefix list)
+// marks a word as one of its terms; a term with that prefix and no definition leaves the reader asking what it is.
+// Only the document's own references (本条, 本契約: self-reference-noun and document-kind) are left. Pure; the parts of
+// speech decide where a prefix is a prefix (本 in 本成果物) and not part of a word (本人, 本日).
+import { definedTerms } from "../structure/definition-use.ts";
+import { prefixGroupsOf, prefixVariants } from "../structure/term-prefix.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
+
+export type UndefinedTerm = { readonly offset: number; readonly term: string };
+
+const NOUNS = new Set(["NOUN", "PROPN"]);
+const QUOTE_PAIRS = [
+  ["「", "」"],
+  ["『", "』"],
+  ['"', '"'],
+  ["“", "”"],
+] as const;
+
+const isNoun = (token: Token | undefined): token is Token => token !== undefined && NOUNS.has(token.pos);
+
+/** A defined term whose rest after the prefix is shorter than this (本人, 本日) is a word, not the document's way of naming terms. */
+const MIN_REST = 2;
+
+/** A prefix written right after a noun is inside a longer word, not a prefix. */
+const continuesWord = (before: Token | undefined, token: Token): boolean => isNoun(before) && before.span.end === token.span.start;
+
+/** The term a prefix token starts: the prefix and the nouns written right after it (本 成果 物). */
+const termAt = (source: string, tokens: readonly Token[], index: number): { readonly offset: number; readonly term: string } | undefined => {
+  const prefix = tokens[index];
+  if (prefix === undefined) return undefined;
+  const run = tokens.slice(index + 1);
+  const length = run.findIndex((token, at) => !isNoun(token) || token.span.start !== (run[at - 1] ?? prefix).span.end);
+  const last = run[(length === -1 ? run.length : length) - 1];
+  return last === undefined ? undefined : { offset: prefix.span.start, term: source.slice(prefix.span.start, last.span.end) };
+};
+
+/** What the decision needs from the document and its word lists. */
+export type TermWords = {
+  readonly prefixes: readonly string[];
+  readonly prefixGroups: readonly (readonly string[])[];
+  /** What the document calls itself and its parts after a prefix (本条, 本契約, 本利用規約); never one of its terms. */
+  readonly selfNouns: readonly string[];
+  /** The term is set in quotes somewhere (「本情報」): defined in a form the structure did not read, or named on purpose. */
+  readonly isQuoted: (term: string) => boolean;
+};
+
+/** The defined terms and their other-prefix forms (本件業務 for 本業務), which defined-term-form reads. */
+const knownForms = (defined: readonly string[], groups: TermWords["prefixGroups"]): string[] => [
+  ...defined,
+  ...defined.flatMap((term) => prefixVariants(term, groups)),
+];
+
+/**
+ * The first use of each term written with the document's prefix and defined nowhere, when the document defines at
+ * least one term with that prefix (else the prefix is not its way of naming terms). A use that starts with a known
+ * form (本サービス上 where 本サービス is defined) is that term.
+ */
+export const undefinedTerms = (source: string, sentences: readonly (readonly Token[])[], defined: readonly string[], words: TermWords): UndefinedTerm[] => {
+  const prefixes = words.prefixes.filter((prefix) => prefix !== "");
+  const prefixed = defined.filter((term) => prefixes.some((prefix) => term.startsWith(prefix) && Array.from(term.slice(prefix.length)).length >= MIN_REST));
+  if (prefixed.length === 0) return [];
+  const known = knownForms(defined, words.prefixGroups);
+  const isSelf = (term: string, prefix: string): boolean => {
+    const rest = term.slice(prefix.length);
+    return words.selfNouns.some((noun) => noun !== "" && (rest.startsWith(noun) || rest.endsWith(noun)));
+  };
+  const uses = sentences.flatMap((tokens) =>
+    tokens.flatMap((token, index) => {
+      if (!prefixes.includes(token.surface) || !isNoun(tokens[index + 1]) || continuesWord(tokens[index - 1], token)) return [];
+      const use = termAt(source, tokens, index);
+      if (use === undefined || isSelf(use.term, token.surface) || words.isQuoted(use.term)) return [];
+      if (known.some((form) => use.term.startsWith(form) || form.startsWith(use.term))) return [];
+      return [use];
+    }),
+  );
+  return uses.filter((use, index) => uses.findIndex((other) => other.term === use.term) === index);
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
+  rule: "undefined-term",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, use.offset),
+  values: { term: use.term, offset: use.offset },
+});
+
+export const undefinedTerm: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const prefixEntries = doc.lexicons["defined-term-prefix"] ?? [];
+  const sentences = doc.sentences.map((sentence) => sentence.tokens ?? []);
+  const defined = definedTerms(doc.structure).map((term) => term.term);
+  return undefinedTerms(doc.source, sentences, defined, {
+    prefixes: prefixEntries.map((entry) => entry.pattern),
+    prefixGroups: prefixGroupsOf(prefixEntries),
+    selfNouns: [...patternsOf(doc, "self-reference-noun"), ...patternsOf(doc, "document-kind")],
+    isQuoted: (term) => QUOTE_PAIRS.some(([open, close]) => doc.source.includes(`${open}${term}${close}`)),
+  }).map((use) => findingOf(doc, use));
+};

package/src/detectors/unknown-word.ts

@@ -1,5 +1,5 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { isKnownWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
+import { isKnownWord, isSplitWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** これより短い語は見ない。短い語は一字違いの語が多すぎて言い直しが決まらず（tost は test か toast か）、略した語（impl）も多い。 */
@@ -26,13 +26,13 @@ const usedOnce = (words: readonly CheckedWord[]): CheckedWord[] => {
 
 /**
  * 辞書に無い英語の語で、一字違いの辞書の語があるもの（recieve → receive）。辞書は adapter が持ち、無い言語では動かない。
- * 大文字を含む語（固有名詞・略語）、コード・URL の中、二度以上使う語、言い直しの無い語は言わない。
+ * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語は言わない。
  */
 export const unknownWord: Detector = (doc): Finding[] => {
   if (doc.dictionary === undefined) return [];
   const speller = spellerOf(doc, doc.dictionary());
   const known = new Set(patternsOf(doc, "known-misspelling"));
-  const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH);
+  const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH).filter(({ offset }) => !isSplitWord(doc.source, offset));
   const used = new Set(words.map(({ word }) => word).filter((word) => isKnownWord(word, speller)));
   return usedOnce(words).flatMap(({ offset, word }) => {
     if (known.has(word) || isKnownWord(word, speller)) return [];

package/src/detectors/vague-deadline.ts

@@ -68,12 +68,12 @@ const concreteIn = (lower: string, entry: string): boolean => {
   );
 };
 
-const statesConcrete = (text: Text, concrete: readonly string[]): boolean => {
+export const statesConcrete = (text: Text, concrete: readonly string[]): boolean => {
   const lower = text.text.toLowerCase();
   return concrete.some((entry) => concreteIn(lower, entry));
 };
 
-const grantsRight = (text: Text, permissions: readonly LexiconEntry[]): boolean => {
+export const grantsRight = (text: Text, permissions: readonly LexiconEntry[]): boolean => {
   const lower = text.text.toLowerCase();
   const ending = withoutEnding(lower);
   return permissions
@@ -86,7 +86,7 @@ const isInsideLonger = (hit: Hit, hits: readonly Hit[]): boolean =>
   hits.some((other) => other.word.length > hit.word.length && other.at <= hit.at && hit.at + hit.word.length <= other.at + other.word.length);
 
 /** The vague limits in one sentence, in order. Matching ignores case. */
-const vagueIn = (text: Text, vague: readonly string[]): VagueDeadline[] => {
+export const vagueIn = (text: Text, vague: readonly string[]): VagueDeadline[] => {
   const lower = text.text.toLowerCase();
   const hits = vague
     .filter((word) => word !== "")

package/src/detectors/version-mismatch.ts

@@ -1,12 +1,16 @@
-// version-mismatch: the version a code block's lead-in names against the one the block shows (structure/version-mismatch.ts).
-// The words that make a version a bound (「から」「以上」, "from", "or later") are the lexicon version-range; the words that
-// lead to the version installed (version, install) are version-lead.
-import type { Detector, Finding } from "../plugin.ts";
+// version-mismatch: the version a code block's lead-in names against the one the block shows (structure/version-mismatch.ts),
+// and an install command that pins the document's own package to a version its release list does not say is current
+// (structure/install-pin.ts). The words that make a version a bound (「から」「以上」, "from", "or later") are the lexicon
+// version-range; the words that lead to the version installed (version, install) are version-lead; the install commands
+// are install-command.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { versionMismatches, type RangeWord, type VersionWords } from "../structure/version-mismatch.ts";
+import { installPinMismatches, ownTextOf, pinsIn } from "../structure/install-pin.ts";
+import { releasesOf } from "../structure/release-list.ts";
 import { codeFences } from "./code-fences.ts";
 import { quoteAt } from "./structure-tree.ts";
 
-export const versionMismatch: Detector = (doc): Finding[] => {
+const leadInFindings = (doc: ProseDocument): Finding[] => {
   const words: VersionWords = {
     ranges: (doc.lexicons["version-range"] ?? []).map((entry): RangeWord => ({ word: entry.pattern, position: entry.position ?? "before" })),
     versionWords: (doc.lexicons["version-lead"] ?? []).map((entry) => entry.pattern),
@@ -21,3 +25,20 @@ export const versionMismatch: Detector = (doc): Finding[] => {
     values: { ...issue.values, offset: issue.offset },
   }));
 };
+
+const installPinFindings = (doc: ProseDocument): Finding[] => {
+  const shapes = (doc.lexicons["install-command"] ?? []).map((entry) => entry.pattern);
+  const headings = doc.markup?.headings ?? [];
+  const releases = releasesOf(doc.source, headings, codeFences(doc.source));
+  return installPinMismatches(pinsIn(doc.source, shapes), releases, ownTextOf(doc.source, headings)).map((issue) => ({
+    rule: "version-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    variant: issue.variant,
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};
+
+export const versionMismatch: Detector = (doc): Finding[] => [...leadInFindings(doc), ...installPinFindings(doc)];

package/src/detectors/version-order.ts

@@ -0,0 +1,50 @@
+// version-order: a changelog's version headings, or a list or table of releases, with one version out of order
+// (structure/version-order.ts).
+import { quoteAt } from "./structure-tree.ts";
+import { codeFences } from "./code-fences.ts";
+import { siblingHeadingRunsOf } from "../structure/heading-runs.ts";
+import { runsOf, type Line } from "../structure/runs.ts";
+import { isVersionHistory, leadingVersion, versionOrderBreaks, type VersionPoint } from "../structure/version-order.ts";
+import type { Detector, Finding, MarkupHeading, ProseDocument } from "../plugin.ts";
+
+const headingPoint = (source: string, heading: MarkupHeading): VersionPoint | undefined => {
+  const label = leadingVersion(heading.text);
+  if (label === undefined) return undefined;
+  const at = source.indexOf(label, heading.start);
+  return { offset: at === -1 ? heading.start : at, label };
+};
+
+/** The marker of a list item or the first pipe of a table row, before the item's text. */
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)]|\|)[ \t]*/u;
+
+const itemVersions = (source: string, run: readonly Line[]): VersionPoint[] =>
+  run.flatMap((line) => {
+    const text = source.slice(line.start, line.end);
+    const marker = ITEM_MARKER.exec(text)?.[0] ?? "";
+    const label = leadingVersion(text.slice(marker.length));
+    return label === undefined ? [] : [{ offset: line.start + marker.length, label }];
+  });
+
+/** A list in a code fence (an example changelog) is not the document's. */
+const outsideFences = (source: string, run: readonly Line[]): Line[] => {
+  const fences = codeFences(source);
+  return run.filter((line) => !fences.some((fence) => line.start >= fence.start && line.start < fence.end));
+};
+
+const pointRuns = (doc: ProseDocument): VersionPoint[][] => [
+  ...siblingHeadingRunsOf(doc.markup?.headings ?? [], (heading) => headingPoint(doc.source, heading)),
+  ...runsOf(doc.source).map((run) => itemVersions(doc.source, outsideFences(doc.source, run))),
+];
+
+export const versionOrder: Detector = (doc): Finding[] =>
+  pointRuns(doc)
+    .filter((run) => isVersionHistory(run.map((point) => point.label)))
+    .flatMap(versionOrderBreaks)
+    .map((issue) => ({
+      rule: "version-order",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));

package/src/detectors/warning-action.ts

@@ -0,0 +1,49 @@
+// warning-without-action: a warning paragraph (Warning:, 注意：, > [!WARNING]) none of whose sentences tells the reader what
+// to do (warning-action.ts). In English a sentence that opens with its verb (Export today's orders first) is an action too.
+// A GitHub alert (> [!WARNING]) is read to the end of its block quote.
+import { isInstruction, isStatement } from "./technical-docs.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { namesAction, quoteBlockEnd, warningTextStart, type WarningWords } from "../warning-action.ts";
+import type { Detector, Finding, Paragraph, ProseDocument, Sentence } from "../plugin.ts";
+
+const wordsOf = (doc: ProseDocument): WarningWords => ({
+  labels: (doc.lexicons["warning-label"] ?? []).map((entry) => entry.pattern),
+  actions: (doc.lexicons["warning-action"] ?? []).map((entry) => entry.pattern),
+});
+
+/** An English sentence that opens with its verb, read from the parts of speech past the label: an instruction. */
+const opensWithVerb = (doc: ProseDocument, sentence: Sentence, from: number): boolean => {
+  const tokens = (sentence.tokens ?? []).filter((token) => token.span.start >= from);
+  return doc.language === "en" && tokens.length > 0 && isInstruction(tokens) && !isStatement(tokens);
+};
+
+const isAction = (doc: ProseDocument, sentence: Sentence, from: number, words: WarningWords): boolean => {
+  const start = Math.max(sentence.span.start, from);
+  if (start >= sentence.span.end) return false;
+  return namesAction(doc.source.slice(start, sentence.span.end), words.actions) || opensWithVerb(doc, sentence, start);
+};
+
+const warningWithoutAction = (doc: ProseDocument, paragraph: Paragraph, words: WarningWords): Finding[] => {
+  const textStart = warningTextStart(doc.source.slice(paragraph.span.start, paragraph.span.end), words.labels);
+  if (textStart === undefined) return [];
+  const from = paragraph.span.start + textStart;
+  const end = quoteBlockEnd(doc.source, paragraph.span.start) ?? paragraph.span.end;
+  const said = doc.sentences.filter((sentence) => sentence.span.end > from && sentence.span.start < end);
+  if (said.length === 0 || said.some((sentence) => isAction(doc, sentence, from, words))) return [];
+  return [
+    {
+      rule: "warning-without-action",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, paragraph.span.start),
+      values: { offset: paragraph.span.start },
+    },
+  ];
+};
+
+export const warningAction: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.labels.length === 0) return [];
+  return doc.paragraphs.flatMap((paragraph) => warningWithoutAction(doc, paragraph, words));
+};

package/src/facts/condition-pairs.ts

@@ -0,0 +1,289 @@
+import type { Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+
+/**
+ * 要約の「XからYに」（"from X to Y"）を、本文が二つの条件（前と後、無いときとあるとき、2025年と2026年）で書いた同じ項目の二つの値と
+ * 組にして比べる。項目の名前が本文の文にあり、二つの値の条件がどちらも読めたときだけ比べる。言語の知識（から、to、前、after）は
+ * 語彙表から取る。
+ */
+export type WordAt = { readonly pattern: string; readonly position: "before" | "after" };
+export type ConditionWord = { readonly pattern: string; readonly group: string };
+
+export type ChangeWords = {
+  /** もとの値に付く語（from、から）。 */
+  readonly from: readonly WordAt[];
+  /** 動いた先の値に付く語（to、に）。 */
+  readonly to: readonly WordAt[];
+  /** 名前と変化のあいだにあれば、変化ではなく幅を言う語（"ranges from 0 to 10"）。 */
+  readonly notChange: readonly string[];
+  /** 名前と値のあいだで飛ばす語（は、が）。 */
+  readonly subjectMarks: readonly string[];
+  /** 名前の語をつなぐ語（の、of）。position が after の語（の）は、前の語が後ろの語を修飾する。短い名前はその前の語を書かないことがある（「無いときの誤りの率」の「誤りの率」）。 */
+  readonly joiners: readonly WordAt[];
+  /** もとの側の条件（before、無いとき）と、動いた先の側の条件（after、あるとき）。同じ group の語どうしが組になる。 */
+  readonly conditionsFrom: readonly ConditionWord[];
+  readonly conditionsTo: readonly ConditionWord[];
+};
+
+export type ChangeSentence = { readonly span: Span; readonly text: string; readonly tokens: readonly Token[]; readonly summary: boolean };
+
+/** 名前（subject）の付いた、もとの値と先の値の組。names は同じ項目を指す名前の書き方（修飾を落とした短い名前も）。 */
+export type ValuePair = {
+  readonly subject: string;
+  readonly key: string;
+  readonly names: readonly string[];
+  readonly from: FactValue;
+  readonly to: FactValue;
+};
+
+export type PairConflict = { readonly summary: ValuePair; readonly body: ValuePair };
+
+const LATIN = /^[A-Za-z]/u;
+const SPACES = /\s+/gu;
+/** 暦の年（2025、2026年）。条件として読み、値としては読まない。日付の一部（2011-10-26、2025年10月）は年の条件ではない。 */
+const YEAR = /(?<![\d.,/-])(?:1[89]|2[01])\d{2}(?![\d.,%/-]|年\d)/gu;
+
+const squeezed = (text: string): string => text.replace(SPACES, "").toLowerCase();
+
+/** 語の現れる所。英字の語は語の切れ目で、ほかは書いたとおりに探す。 */
+const wordSpans = (text: string, word: string, offset: number): Span[] => {
+  const pattern = LATIN.test(word) ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...text.matchAll(pattern)].map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length }));
+};
+
+const endsWithWord = (text: string, word: string): boolean => {
+  const lowered = text.trimEnd().toLowerCase();
+  if (!lowered.endsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word) || !/[A-Za-z]$/u.test(lowered.slice(0, lowered.length - word.length));
+};
+
+const startsWithWord = (text: string, word: string): boolean => {
+  const lowered = text.trimStart().toLowerCase();
+  if (!lowered.startsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word) || !/^[A-Za-z]/u.test(lowered.slice(word.length));
+};
+
+const patternsAt = (words: readonly WordAt[], position: WordAt["position"]): string[] =>
+  words.filter((word) => word.position === position).map((word) => word.pattern);
+
+/** 二つの値のあいだが、もとの値の後ろの語と先の値の前の語だけか（" to "、「から」）。 */
+const joinsChange = (between: string, words: ChangeWords): boolean => {
+  const fromAfter = ["", ...patternsAt(words.from, "after")];
+  const toBefore = ["", ...patternsAt(words.to, "before")];
+  const shown = squeezed(between);
+  return shown !== "" && fromAfter.some((first) => toBefore.some((second) => squeezed(first + second) === shown));
+};
+
+/** 前に要る語（from）があれば、その語の始まり。要らなければ値の始まり。無ければ undefined。 */
+const changeStart = (source: string, value: FactValue, words: ChangeWords): number | undefined => {
+  const before = patternsAt(words.from, "before");
+  if (before.length === 0) return value.start;
+  const head = source.slice(0, value.start);
+  const found = before.find((word) => endsWithWord(head, word));
+  return found === undefined ? undefined : head.trimEnd().length - found.length;
+};
+
+const TAIL_LENGTH = 40;
+
+const endsChange = (source: string, value: FactValue, words: ChangeWords): boolean => {
+  const after = patternsAt(words.to, "after");
+  const tail = source.slice(value.end, value.end + TAIL_LENGTH);
+  return after.length === 0 || after.some((word) => startsWithWord(tail, word));
+};
+
+const isYear = (source: string, value: FactValue): boolean => value.unit === "" && /^(?:1[89]|2[01])\d{2}$/u.test(source.slice(value.start, value.end));
+
+const isQuantityPair = (source: string, from: FactValue, to: FactValue): boolean =>
+  from.kind === "quantity" && comparable(from, to) && !isYear(source, from) && !isYear(source, to);
+
+const isBlank = (token: Token): boolean => token.surface.trim() === "";
+const SKIPPED: ReadonlySet<string> = new Set(["VERB", "AUX", "ADV"]);
+const NAME_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ"]);
+const HEAD_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+const DIGIT = /\d/u;
+
+const isSkipped = (token: Token, marks: ReadonlySet<string>): boolean => isBlank(token) || marks.has(token.surface) || SKIPPED.has(token.pos);
+
+const joinerSet = (words: ChangeWords): ReadonlySet<string> => new Set(words.joiners.map((word) => word.pattern.toLowerCase()));
+
+const isNameToken = (token: Token, joiners: ReadonlySet<string>): boolean =>
+  (NAME_WORD.has(token.pos) && !DIGIT.test(token.surface)) || joiners.has(token.surface.toLowerCase());
+
+const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(SPACES, " ");
+
+/** 名前の並びを、つなぐ語で始まらず名詞で終わるところまで切る。 */
+const trimmedName = (run: readonly Token[], joiners: ReadonlySet<string>): Token[] => {
+  const named = run.slice(
+    Math.max(
+      0,
+      run.findIndex((token) => !joiners.has(token.surface.toLowerCase())),
+    ),
+  );
+  return named.slice(0, named.findLastIndex((token) => HEAD_WORD.has(token.pos)) + 1);
+};
+
+/** 一つの名前の書き方: 全体と、修飾の語（「無いときの」）を前から落としたもの。 */
+const namesOf = (source: string, named: readonly Token[], words: ChangeWords): string[] => {
+  const last = named.at(-1);
+  if (last === undefined) return [];
+  const dropping = new Set(words.joiners.filter((word) => word.position === "after").map((word) => word.pattern.toLowerCase()));
+  const starts = [0, ...named.flatMap((token, index) => (dropping.has(token.surface.toLowerCase()) ? [index + 1] : []))];
+  return starts.flatMap((start) => {
+    const first = named[start];
+    return first === undefined ? [] : [keyOf(source.slice(first.span.start, last.span.end))];
+  });
+};
+
+/** 文の中の名前の並び（名詞と、つなぐ語でつながる語）ごとの、名前の書き方。 */
+const namesIn = (source: string, sentence: ChangeSentence, words: ChangeWords): Set<string> => {
+  const joiners = joinerSet(words);
+  const runs = sentence.tokens.reduce<Token[][]>((found, token, index) => {
+    if (!isNameToken(token, joiners)) return found;
+    const previous = sentence.tokens[index - 1];
+    const current = previous !== undefined && isNameToken(previous, joiners) ? found.at(-1) : undefined;
+    if (current === undefined) found.push([token]);
+    else current.push(token);
+    return found;
+  }, []);
+  return new Set(runs.flatMap((run) => namesOf(source, trimmedName(run, joiners), words)));
+};
+
+/**
+ * 変化の前の名前の語の並び（"error rate"、「誤りの率」）。その前の空白、は・が、動詞（"the rate fell from"）は飛ばす。
+ * つなぐ語で始まらず、名詞で終わる。
+ */
+const nameTokens = (tokens: readonly Token[], words: ChangeWords): Token[] => {
+  const marks = new Set(words.subjectMarks);
+  const joiners = joinerSet(words);
+  const head = tokens.slice(0, tokens.findLastIndex((token) => !isSkipped(token, marks)) + 1);
+  const run = head.slice(head.findLastIndex((token) => !isNameToken(token, joiners)) + 1);
+  const named = trimmedName(run, joiners);
+  return HEAD_WORD.has(run.at(-1)?.pos ?? "") ? named : [];
+};
+
+type Subject = { readonly subject: string; readonly key: string; readonly names: readonly string[] };
+
+const subjectBefore = (source: string, sentence: ChangeSentence, offset: number, words: ChangeWords): Subject | undefined => {
+  const named = nameTokens(
+    sentence.tokens.filter((token) => token.span.end <= offset),
+    words,
+  );
+  const [first, last] = [named[0], named.at(-1)];
+  if (first === undefined || last === undefined) return undefined;
+  const subject = source.slice(first.span.start, last.span.end);
+  const gap = source.slice(last.span.end, offset);
+  if (words.notChange.some((word) => wordSpans(gap, word, 0).length > 0)) return undefined;
+  return { subject, key: keyOf(subject), names: namesOf(source, named, words) };
+};
+
+/** 文の中の「XからYに」と、その前の名前。 */
+const changesIn = (source: string, sentence: ChangeSentence, values: readonly FactValue[], words: ChangeWords): ValuePair[] =>
+  values.slice(0, -1).flatMap((from, index): ValuePair[] => {
+    const to = values[index + 1];
+    if (to === undefined || !isQuantityPair(source, from, to) || !joinsChange(source.slice(from.end, to.start), words)) return [];
+    const start = changeStart(source, from, words);
+    if (start === undefined || !endsChange(source, to, words)) return [];
+    const named = subjectBefore(source, sentence, start, words);
+    return named === undefined ? [] : [{ ...named, from, to }];
+  });
+
+type Mark = Span & { readonly side: "from" | "to"; readonly group: string; readonly year?: number };
+
+const conditionMarks = (sentence: ChangeSentence, words: readonly ConditionWord[], side: Mark["side"]): Mark[] =>
+  words.flatMap((word) => wordSpans(sentence.text, word.pattern, sentence.span.start).map((span): Mark => ({ ...span, side, group: word.group })));
+
+const yearMarks = (sentence: ChangeSentence): Mark[] =>
+  [...sentence.text.matchAll(YEAR)].map((match) => {
+    const start = sentence.span.start + match.index;
+    return { start, end: start + match[0].length, side: "from", group: "year", year: Number(match[0]) };
+  });
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+/** 年の組は、早い年がもとの側。違う年がちょうど二つのときだけ。 */
+const yearPair = (marks: readonly Mark[]): Mark[] | undefined => {
+  const years = marks.filter((mark) => mark.group === "year");
+  const [first, second] = years;
+  if (years.length !== 2 || first === undefined || second === undefined || first.year === second.year) return undefined;
+  const later = (first.year ?? 0) < (second.year ?? 0) ? second : first;
+  return years.map((mark) => (mark === later ? { ...mark, side: "to" } : mark));
+};
+
+/** 一つの組の語が、もとの側と先の側に一つずつ。そういう組がちょうど一つのときだけ、その二つ。 */
+const conditionPair = (marks: readonly Mark[]): Mark[] | undefined => {
+  const groups = [...new Set(marks.map((mark) => mark.group))];
+  const pairs = groups.flatMap((group) => {
+    if (group === "year") return [yearPair(marks)].filter((pair) => pair !== undefined);
+    const inGroup = marks.filter((mark) => mark.group === group);
+    const sides = new Set(inGroup.map((mark) => mark.side));
+    return inGroup.length === 2 && sides.size === 2 ? [inGroup] : [];
+  });
+  return pairs.length === 1 ? pairs[0] : undefined;
+};
+
+const CLAUSE_BREAK = /[,;、，；]/u;
+
+/** 二つの範囲のあいだに、句の切れ目（, ; 、）がある。 */
+const brokenBetween = (sentence: ChangeSentence, left: Span, right: Span): boolean =>
+  CLAUSE_BREAK.test(sentence.text.slice(left.end - sentence.span.start, right.start - sentence.span.start));
+
+/**
+ * 条件と値が、条件・値・条件・値か、値・条件・値・条件の順に並び、二組のあいだが句の切れ目で分かれるときだけ、どの値がどの条件の
+ * ものか決まる。切れ目が無いと（"With breaks, against 2.4% without them, … 1.6%"）、条件が前と後ろのどちらの値に付くか決まらない。
+ */
+const pairByOrder = (sentence: ChangeSentence, conditions: readonly Mark[], values: readonly FactValue[]): { from: FactValue; to: FactValue } | undefined => {
+  const [c1, c2] = conditions.toSorted((left, right) => left.start - right.start);
+  const [v1, v2] = values;
+  if (c1 === undefined || c2 === undefined || v1 === undefined || v2 === undefined) return undefined;
+  const leads = c1.end <= v1.start && v1.end <= c2.start && c2.end <= v2.start && brokenBetween(sentence, v1, c2);
+  const follows = v1.end <= c1.start && c1.end <= v2.start && v2.end <= c2.start && brokenBetween(sentence, c1, v2);
+  if (!leads && !follows) return undefined;
+  return c1.side === "from" ? { from: v1, to: v2 } : { from: v2, to: v1 };
+};
+
+/** 本文の一文が、名前と、比べられる二つの値と、その二つの条件を書いていれば、その組。 */
+const conditionedPair = (sentence: ChangeSentence, values: readonly FactValue[], summary: ValuePair, words: ChangeWords): ValuePair | undefined => {
+  const marks = [...conditionMarks(sentence, words.conditionsFrom, "from"), ...conditionMarks(sentence, words.conditionsTo, "to"), ...yearMarks(sentence)];
+  const free = marks.filter((mark) => mark.group === "year" || !values.some((value) => overlaps(mark, value)));
+  const measured = values.filter((value) => comparable(summary.from, value) && !free.some((mark) => overlaps(mark, value)));
+  const conditions = conditionPair(free);
+  if (measured.length !== 2 || conditions === undefined) return undefined;
+  const pair = pairByOrder(sentence, conditions, measured);
+  return pair === undefined ? undefined : { ...summary, ...pair };
+};
+
+const within = (span: Span, values: readonly FactValue[]): FactValue[] => values.filter((value) => value.start >= span.start && value.end <= span.end);
+
+const samePair = (left: ValuePair, right: ValuePair): boolean => sameValue(left.from, right.from) && sameValue(left.to, right.to);
+
+/** 本文の組。本文に書いた「XからYに」と、条件で分けて書いた二つの値。 */
+const bodyPairs = (source: string, sentences: readonly ChangeSentence[], values: readonly FactValue[], summary: ValuePair, words: ChangeWords): ValuePair[] =>
+  sentences
+    .filter((sentence) => !sentence.summary)
+    .flatMap((sentence) => {
+      const inside = within(sentence.span, values);
+      const changes = changesIn(source, sentence, inside, words).filter((change) => change.names.includes(summary.key));
+      const conditioned = namesIn(source, sentence, words).has(summary.key) ? conditionedPair(sentence, inside, summary, words) : undefined;
+      return [...changes, ...(conditioned === undefined ? [] : [conditioned])];
+    })
+    .filter((pair) => comparable(summary.from, pair.from) && comparable(summary.to, pair.to));
+
+/** 要約の「XからYに」が、本文で一通りに書いた同じ名前の組と違う。本文の組が無いか二通り以上なら言わない。 */
+export const conditionPairConflicts = (
+  source: string,
+  sentences: readonly ChangeSentence[],
+  values: readonly FactValue[],
+  words: ChangeWords,
+): PairConflict[] =>
+  sentences
+    .filter((sentence) => sentence.summary)
+    .flatMap((sentence) => changesIn(source, sentence, within(sentence.span, values), words))
+    .flatMap((summary) => {
+      const distinct = bodyPairs(source, sentences, values, summary, words).reduce<ValuePair[]>(
+        (kept, pair) => (kept.some((seen) => samePair(seen, pair)) ? kept : [...kept, pair]),
+        [],
+      );
+      const [only] = distinct;
+      return distinct.length !== 1 || only === undefined || samePair(summary, only) ? [] : [{ summary, body: only }];
+    });

package/src/facts/event-dates.ts

@@ -0,0 +1,63 @@
+import type { Span } from "../plugin.ts";
+import { sameValue, type FactValue } from "./fact-values.ts";
+
+/**
+ * 出来事の日付。文が出来事の語（提供、release）を一つの組だけ含み、日付を一つだけ持つとき、その日付をその出来事の日付と読む。
+ * 冒頭や要約の文の日付を、本文の同じ組の出来事の日付と比べる。本文の日付が一通りに揃っていて、違うときだけ言う。
+ * 年月日まで書いた日付どうしだけを比べる。日付が二つある文（期間）や、組が二つある文（発表した日と提供する日）は読まない。
+ * 本文の文が、冒頭の文に無い名前（別の製品、別の催し）を持つなら、別の出来事として比べない。
+ */
+export type EventWord = { readonly pattern: string; readonly group: string };
+
+/** names: 文の中の固有名詞などの名前。 */
+export type EventSentence = Span & { readonly text: string; readonly summary: boolean; readonly names: readonly string[] };
+
+export type EventDateConflict = { readonly label: string; readonly value: FactValue; readonly other: FactValue };
+
+type EventDate = { readonly group: string; readonly label: string; readonly value: FactValue; readonly sentence: EventSentence };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+const normalized = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const startsWord = (text: string, at: number): boolean => at === 0 || !/[a-z]/u.test(text.charAt(at - 1));
+
+/** 文の中の出来事の語。英字の語は語の頭からだけ（releases は release、prerelease は違う）。 */
+const wordsIn = (text: string, words: readonly EventWord[]): EventWord[] => {
+  const folded = normalized(text);
+  return words.filter((word) => {
+    const pattern = normalized(word.pattern);
+    const at = folded.indexOf(pattern);
+    return at >= 0 && (!/^[a-z]/u.test(pattern) || startsWord(folded, at));
+  });
+};
+
+const inside = (sentence: Span, value: Span): boolean => sentence.start <= value.start && value.end <= sentence.end;
+
+const eventDateOf = (sentence: EventSentence, dates: readonly FactValue[], words: readonly EventWord[]): EventDate[] => {
+  const own = dates.filter((date) => inside(sentence, date));
+  const found = wordsIn(sentence.text, words);
+  const groups = new Set(found.map((word) => word.group));
+  const [date, word] = [own[0], found[0]];
+  if (own.length !== 1 || groups.size !== 1 || date === undefined || word === undefined || !FULL_DATE.test(date.key)) return [];
+  return [{ group: word.group, label: word.pattern, value: date, sentence }];
+};
+
+const distinct = (values: readonly FactValue[]): FactValue[] =>
+  values.reduce<FactValue[]>((kept, value) => (kept.some((seen) => sameValue(seen, value)) ? kept : [...kept, value]), []);
+
+/** 本文の文の名前が、どれも冒頭の文にある（名前の無い「提供開始日は」も同じ出来事と読む）。 */
+const sameSubject = (event: EventDate, other: EventDate): boolean => other.sentence.names.every((name) => event.sentence.names.includes(name));
+
+const conflictOf = (event: EventDate, body: readonly EventDate[]): EventDateConflict[] => {
+  const values = distinct(body.filter((other) => other.group === event.group && sameSubject(event, other)).map((other) => other.value));
+  const only = values.length === 1 ? values[0] : undefined;
+  return only === undefined || sameValue(event.value, only) ? [] : [{ label: event.label, value: event.value, other: only }];
+};
+
+/** 冒頭や要約の出来事の日付が、本文で揃って書かれた同じ出来事の日付と違う。dates は日付の値だけ。 */
+export const eventDateConflicts = (sentences: readonly EventSentence[], dates: readonly FactValue[], words: readonly EventWord[]): EventDateConflict[] => {
+  const events = sentences.flatMap((sentence) => eventDateOf(sentence, dates, words));
+  const body = events.filter((event) => !event.sentence.summary);
+  return events.filter((event) => event.sentence.summary).flatMap((event) => conflictOf(event, body));
+};