chaffjs 0.31.0 → 0.32.0

package/src/detectors/whole-count-findings.ts

@@ -0,0 +1,48 @@
+import type { Finding, ProseDocument } from "../plugin.ts";
+import { wholeCountConflicts, type CountWord, type CountWords, type MarkWord, type WholeCountConflict } from "../facts/whole-counts.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const countWordsAt = (doc: ProseDocument, id: string): CountWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): CountWord => ({ pattern: entry.pattern, group: entry.group ?? "" }));
+
+const markWordsAt = (doc: ProseDocument, id: string): MarkWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): MarkWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const countWordsOf = (doc: ProseDocument): CountWords => ({
+  columns: countWordsAt(doc, "fact-count-column"),
+  counters: countWordsAt(doc, "fact-count-counter"),
+  separateRows: patternsOf(doc, "fact-count-separate-rows"),
+  wholeMarks: markWordsAt(doc, "fact-count-whole"),
+  notWhole: markWordsAt(doc, "fact-count-not-whole"),
+  restating: patternsOf(doc, "fact-count-restating"),
+  totalLabels: (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group !== "subtotal").map((entry) => entry.pattern),
+  subtotalLabels: (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group === "subtotal").map((entry) => entry.pattern),
+});
+
+const wholeCountFinding =
+  (doc: ProseDocument) =>
+  (conflict: WholeCountConflict): Finding => {
+    const value = doc.source.slice(conflict.start, conflict.end);
+    return {
+      rule: "fact-conflict",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, conflict.start),
+      variant: conflict.table.sum ? "whole-count-sum" : "whole-count",
+      values: {
+        label: conflict.heading,
+        value,
+        other: `${String(conflict.table.count)}${value.slice(conflict.written.length)}`,
+        offset: conflict.start,
+      },
+    };
+  };
+
+/** 文が全体として書いた数（合計4枚）と、表のその数を数える列の全体の数。 */
+export const wholeCountFindings = (doc: ProseDocument): Finding[] => {
+  const sentences = doc.sentences.map((sentence) => ({ ...sentence.span, text: doc.source.slice(sentence.span.start, sentence.span.end) }));
+  return wholeCountConflicts(doc.source, sentences, countWordsOf(doc)).map(wholeCountFinding(doc));
+};

package/src/detectors/working-hours-findings.ts

@@ -0,0 +1,100 @@
+import type { Finding, ProseDocument, Span } from "../plugin.ts";
+import { timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { clockRanges, workingHoursMismatches, type WorkingHoursMismatch, type WorkingHoursWords } from "../derived/working-hours.ts";
+import { timesheetHoursMismatches, type TimesheetMismatch } from "../derived/timesheet-hours.ts";
+import { computedLength, type ComputedLength } from "../derived/hours-and-minutes.ts";
+import { cellMinutes, showsOvernightWork } from "../structure/shift-times.ts";
+import { clockTimes } from "../compare/clock-time.ts";
+import { secondsOf, type TimeSpan } from "../structure/time-marks.ts";
+import { marksOf } from "./use-count-words.ts";
+
+// duration-mismatch の勤務時間: 文の中の「9:00〜17:30、休憩1時間、実働8時間」と、勤務表の行（始業 | 終業 | 休憩 | 実働）。
+
+/** duration-mismatch の指摘を作る関数（derived-numbers.ts の finding）。 */
+type FindingOf = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string) => Finding;
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** The hour and minute units of unit-time, told apart by their weight in seconds. */
+const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+const lengthWords = (doc: ProseDocument): LengthWords => ({
+  hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
+  minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
+  halves: patternsOf(doc, "length-half"),
+  numberWords: patternsOf(doc, "count-number"),
+});
+
+export const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] => timeLengths(text, lengthWords(doc));
+
+/** The variant suffix for each way of writing the computed length: 4時間15分 takes none, 7時間 "-hours", 45分 "-minutes". */
+const SHAPE_SUFFIX: Readonly<Record<ComputedLength["shape"], string>> = { "hours-minutes": "", hours: "-hours", minutes: "-minutes" };
+
+const workingHoursFinding = (doc: ProseDocument, mismatch: WorkingHoursMismatch, finding: FindingOf): Finding[] => {
+  const length = computedLength(mismatch.expected, mismatch.total.minutes);
+  if (length === undefined) return [];
+  const values = {
+    start: written(doc, mismatch.start),
+    end: written(doc, mismatch.end),
+    break: written(doc, mismatch.break),
+    total: written(doc, mismatch.total),
+    ...length.values,
+  };
+  return [finding(doc, mismatch.total.start, values, `working-hours${SHAPE_SUFFIX[length.shape]}`)];
+};
+
+const workingHoursWords = (doc: ProseDocument): WorkingHoursWords => ({
+  joiners: patternsOf(doc, "clock-range-joiner"),
+  dayShifts: marksOf(doc, "day-shift-mark"),
+  breaks: marksOf(doc, "working-hours-break"),
+  totals: marksOf(doc, "working-hours-total"),
+  approximate: marksOf(doc, "approximate-marker"),
+});
+
+const timesIn = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
+
+/** 始業から終業まで、休憩を除いた時間が、書いた実働と合わない。 */
+const workingHoursOf = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] =>
+  workingHoursMismatches(text, doc.source, sentencesOf(doc), timesIn(text), lengthsOf(doc, text), workingHoursWords(doc)).flatMap((mismatch) =>
+    workingHoursFinding(doc, mismatch, finding),
+  );
+
+const timesheetFinding = (doc: ProseDocument, mismatch: TimesheetMismatch, finding: FindingOf): Finding[] => {
+  const times = { start: written(doc, mismatch.start), end: written(doc, mismatch.end), break: written(doc, mismatch.break) };
+  if (mismatch.total === undefined) return [finding(doc, mismatch.break.start, times, "working-hours-break-longer")];
+  const length = computedLength(mismatch.expected, mismatch.total.minutes);
+  if (length === undefined) return [];
+  return [
+    finding(doc, mismatch.total.start, { ...times, total: written(doc, mismatch.total), ...length.values }, `working-hours${SHAPE_SUFFIX[length.shape]}`),
+  ];
+};
+
+/** 勤務表の行（始業 | 終業 | 休憩 | 実働）の実働が、終わりから始まりと休憩を引いた長さと合わない。 */
+const timesheetHoursOf = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] => {
+  const times = timesIn(text);
+  const words = workingHoursWords(doc);
+  const timeWords = { legs: [], columns: [], dayShifts: words.dayShifts, zones: [] };
+  return timesheetHoursMismatches({
+    text,
+    times,
+    ranges: clockRanges(text, times, words),
+    columns: marksOf(doc, "shift-column"),
+    overnight: showsOvernightWork(text, times, marksOf(doc, "overnight-work-mark"), timeWords),
+    lengthOf: (cell, bareHours) => cellMinutes(cell, lengthsOf(doc, cell), bareHours),
+  }).flatMap((mismatch) => timesheetFinding(doc, mismatch, finding));
+};
+
+/** 文の中の勤務時間と勤務表の行。同じ実働を両方から読んでも一度だけ言う。 */
+export const workingHoursFindings = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] => {
+  const inline = workingHoursOf(doc, text, finding);
+  const said = new Set(inline.map((found) => found.values?.["offset"]));
+  return [...inline, ...timesheetHoursOf(doc, text, finding).filter((found) => !said.has(found.values?.["offset"]))];
+};

package/src/facts/age-values.ts

@@ -0,0 +1,124 @@
+import type { FactValue } from "./fact-values.ts";
+
+/**
+ * 年齢の値（満70歳、20歳、aged 40、30 years old）と、年齢の上限（満70歳まで、up to the age of 70）、年齢の範囲（満20歳〜満70歳、
+ * aged 20 to 70）。値を年齢の印の語まで延ばし、数だけの値として読む（年齢は、年齢の行の升の 70 と同じもの）。
+ * 範囲は上の端を値にして、下の端を lower に持つ。範囲と上限は、どちらも加入できる上の年齢を言うので上の端で比べる。
+ * 一人の年齢（20歳）は範囲の中のどれでもありうるので、範囲とは比べない（comparable）。
+ */
+export type AgeWord = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type AgeWords = {
+  /** 年齢の印（満、歳、aged、the age of、years old）。 */
+  readonly marks: readonly AgeWord[];
+  /** 上限の印（まで、以下、up to、or under）。 */
+  readonly limits: readonly AgeWord[];
+  /** 二つの年齢のあいだに置いて範囲を言う語（〜、から、to）。 */
+  readonly joiners: readonly string[];
+};
+
+/** 印まで延ばした値と、印があったか。 */
+type Marked = { readonly age: FactValue; readonly marked: boolean };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const LATIN_LETTER = /[a-z]/iu;
+const GAPS = new Set([" ", "\t"]);
+
+const isLatin = (char: string): boolean => LATIN_LETTER.test(char);
+
+/** 語の前の字。英字の語は、前が英字でないときだけ語の頭。 */
+const startsWord = (source: string, at: number, pattern: string): boolean => !(isLatin(pattern.charAt(0)) && isLatin(source.charAt(at - 1)));
+
+const endsWord = (source: string, at: number, pattern: string): boolean => !(isLatin(pattern.slice(-1)) && isLatin(source.charAt(at)));
+
+/** at の前に書いた一番長い語の始まり。英字の語の後ろの空白一つは飛ばす。 */
+const wordBefore = (source: string, at: number, patterns: readonly string[]): number | undefined =>
+  patterns
+    .flatMap((pattern) => {
+      const gap = isLatin(pattern.slice(-1)) && GAPS.has(source.charAt(at - 1)) ? 1 : 0;
+      const from = at - gap - pattern.length;
+      const written = from >= 0 && folded(source.slice(from, at - gap)) === folded(pattern);
+      return written && startsWord(source, from, pattern) ? [from] : [];
+    })
+    .reduce<number | undefined>((earliest, from) => (earliest === undefined || from < earliest ? from : earliest), undefined);
+
+/** at の後ろに書いた一番長い語の終わり。英字の語の前の空白一つは飛ばす。 */
+const wordAfter = (source: string, at: number, patterns: readonly string[]): number | undefined =>
+  patterns
+    .flatMap((pattern) => {
+      const gap = isLatin(pattern.charAt(0)) && GAPS.has(source.charAt(at)) ? 1 : 0;
+      const to = at + gap + pattern.length;
+      const written = folded(source.slice(at + gap, to)) === folded(pattern);
+      return written && endsWord(source, to, pattern) ? [to] : [];
+    })
+    .reduce<number | undefined>((latest, to) => (latest === undefined || to > latest ? to : latest), undefined);
+
+const at = (words: readonly AgeWord[], position: AgeWord["position"]): string[] =>
+  words.filter((word) => word.position === position).map((word) => word.pattern);
+
+/** 値の字の終わりにすでに年齢の印がある（70歳）。 */
+const endsWithMark = (source: string, value: FactValue, marks: readonly string[]): boolean =>
+  marks.some((mark) => folded(source.slice(value.start, value.end)).endsWith(folded(mark)));
+
+/** 単位の無い数か、単位が年齢の印の頭（30 years old の years）か、印で終わる値（70歳）だけが年齢になりうる。 */
+const mayBeAge = (source: string, value: FactValue, after: readonly string[]): boolean =>
+  value.kind === "quantity" && (value.unit === "" || endsWithMark(source, value, after) || after.some((mark) => folded(mark).startsWith(folded(value.unit))));
+
+/** 年齢の印まで延ばした値。印が無ければ marked は false（範囲の片方なら年齢として読む）。 */
+const markedAge = (source: string, value: FactValue, words: AgeWords): Marked => {
+  const after = at(words.marks, "after");
+  const inside = endsWithMark(source, value, after);
+  const end = inside ? value.end : wordAfter(source, value.end, after);
+  const start = wordBefore(source, value.start, at(words.marks, "before"));
+  const age: FactValue = { ...value, start: start ?? value.start, end: end ?? value.end, unit: "" };
+  return { age, marked: inside || start !== undefined || end !== undefined };
+};
+
+/** 上限の印まで延ばした値。印があれば上の端。 */
+const withLimit = (source: string, value: FactValue, words: AgeWords): FactValue => {
+  const start = wordBefore(source, value.start, at(words.limits, "before"));
+  const end = wordAfter(source, value.end, at(words.limits, "after"));
+  if (start === undefined && end === undefined) return value;
+  return { ...value, start: start ?? value.start, end: end ?? value.end, bound: "upper" };
+};
+
+/** 二つの値のあいだが範囲の語だけか（まわりの空白は許す）。 */
+const MAX_GAP = 2;
+
+const joined = (source: string, left: Marked, right: Marked, joiners: readonly string[]): boolean => {
+  const between = source.slice(left.age.end, right.age.start);
+  const trimmed = folded(between.trim());
+  return between.length - trimmed.length <= MAX_GAP && joiners.some((joiner) => folded(joiner) === trimmed);
+};
+
+/** 範囲の上の端の値。下の端は lower。下の端が上の端より大きければ範囲と読まない。 */
+const rangeOf = ({ age: lower }: Marked, { age: upper }: Marked): FactValue | undefined => {
+  if (Number(lower.key) > Number(upper.key)) return undefined;
+  return { start: lower.start, end: upper.end, kind: "quantity", key: upper.key, unit: "", lower: lower.key, bound: "upper" };
+};
+
+type Reading = { readonly ages: FactValue[]; readonly skip: boolean };
+
+const readAges = (source: string, values: readonly FactValue[], words: AgeWords): FactValue[] => {
+  const after = at(words.marks, "after");
+  const candidates = values.filter((value) => mayBeAge(source, value, after)).map((value) => markedAge(source, value, words));
+  return candidates.reduce<Reading>(
+    ({ ages, skip }, left, index) => {
+      if (skip) return { ages, skip: false };
+      const right = candidates[index + 1];
+      const range = right !== undefined && (left.marked || right.marked) && joined(source, left, right, words.joiners) ? rangeOf(left, right) : undefined;
+      if (range !== undefined) return { ages: [...ages, withLimit(source, range, words)], skip: true };
+      return { ages: left.marked ? [...ages, withLimit(source, left.age, words)] : ages, skip: false };
+    },
+    { ages: [], skip: false },
+  ).ages;
+};
+
+/** 年齢の印の付いた数と、印の付いた年齢を片方に持つ範囲を、印の語まで含む年齢の値にして返す。文書の中の順。 */
+export const ageValues = (source: string, values: readonly FactValue[], words: AgeWords): FactValue[] =>
+  readAges(
+    source,
+    values.toSorted((left, right) => left.start - right.start),
+    words,
+  );

package/src/facts/cell-keys.ts

@@ -0,0 +1,21 @@
+import { keyOfParts, type QualifierWords } from "./qualified-labels.ts";
+import type { TableFact } from "./table-facts.ts";
+
+/**
+ * 行と列で名前の決まる表の升（| 主回線 | … | 13.6GB | の、列 データ利用量）を、同じ範囲の文が条件を付けて書いた同じ名前（主回線の
+ * データ利用量、data used (primary line)）と同じ key にする。列が名前で行が条件の読み（データ利用量 (主回線)）と、行が名前で列が条件の
+ * 読み（売上高 (当期)）のうち、同じ範囲の表の外の値の key にあるものがちょうど一つのときだけ。どちらも無いか両方あれば、升の key は
+ * 書いたまま。行の条件が key に入るので、別の行（副回線）の値とは比べない。
+ */
+export const withCellKeys = <T extends TableFact & { readonly scope: string }>(facts: readonly T[], words: QualifierWords): T[] => {
+  const written = new Set(facts.filter((fact) => fact.table !== true).map((fact) => `${fact.scope}\n${fact.key}`));
+  return facts.map((fact) => {
+    if (fact.cell === undefined) return fact;
+    const { row, column } = fact.cell;
+    const keys = [keyOfParts(column, row, words), keyOfParts(row, column, words)].filter(
+      (key): key is string => key !== undefined && written.has(`${fact.scope}\n${key}`),
+    );
+    const [key, ...others] = keys;
+    return key === undefined || others.length > 0 ? fact : { ...fact, key };
+  });
+};

package/src/facts/count-labels.ts

@@ -0,0 +1,28 @@
+import type { Lexicon, Span } from "../plugin.ts";
+import type { FactValue } from "./fact-values.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 数えた数で始まる名前（「1箱の重さ」「1人あたりの料金」）。数は名前の一部で、「2箱の重さ」は別の項目。
+ * 年や月や日付で始まる名前（「2026年の売上」）は、数えた数ではないので読まない。数える語と続きの語は言語パッケージの語彙表から取る。
+ */
+export type CountLabelWords = { readonly counters: readonly string[]; readonly links: readonly string[] };
+
+/** 二つの lexicon（fact-label-counter、fact-label-count-link）の語。 */
+export const countLabelWordsOf = (lexicons: Readonly<Record<string, Lexicon>>): CountLabelWords => ({
+  counters: (lexicons["fact-label-counter"] ?? []).map((entry) => entry.pattern),
+  links: (lexicons["fact-label-count-link"] ?? []).map((entry) => entry.pattern),
+});
+
+const LETTER = /\p{L}/u;
+
+const normalized = (text: string): string => text.normalize("NFKC");
+
+/** value が、cell の頭に書いた数えた数で、そのすぐ後ろに続きの語と名前の字があるか。 */
+export const isCountLabelHead = (source: string, cell: Span, value: FactValue, words: CountLabelWords): boolean => {
+  if (value.kind !== "quantity" || withoutEdgeMarks(source.slice(cell.start, value.start)) !== "") return false;
+  if (!words.counters.some((counter) => normalized(counter) === value.unit)) return false;
+  const after = source.slice(value.end, cell.end);
+  const link = words.links.find((word) => after.startsWith(word));
+  return link !== undefined && LETTER.test(after.slice(link.length));
+};

package/src/facts/document-terms.ts

@@ -0,0 +1,107 @@
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+import type { ScopedFact } from "./fact-scope.ts";
+import type { FactConflict } from "./fact-conflicts.ts";
+
+/**
+ * 文書全体で一つの値を持つ項目（試用期間、probation period）。語彙表の語の名前の値は、節をまたいで比べる。比べるのは、拠り所の値と
+ * 文の値のあいだだけ: 拠り所（表の升か、見出しがその項目の名前の節「第2条（保証期間）」の値）がその項目に一通りの値を書き、別の所の
+ * 文がそれと違う値を書いたとき、文の値を言う。
+ * 名前に条件を書いた値（正社員の試用期間）は名前が語彙表の語と違うので比べない。表どうし、文どうしは、雇用形態ごとに並べた
+ * 節のことがあるので比べない。拠り所が二通りの値を書いていれば、別々のものの値として言わない。
+ */
+export type TermWord = { readonly pattern: string; readonly group: string };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const MAX_DISTINCT = 2;
+
+const distinctValues = (values: readonly FactValue[]): FactValue[] =>
+  values.reduce<FactValue[]>((kept, value) => (kept.some((seen) => sameValue(seen, value)) ? kept : [...kept, value]), []);
+
+const comparableClasses = (facts: readonly ScopedFact[]): ScopedFact[][] =>
+  facts.reduce<ScopedFact[][]>((classes, fact) => {
+    const home = classes.find((members) => members[0] !== undefined && comparable(members[0].value, fact.value));
+    if (home === undefined) classes.push([fact]);
+    else home.push(fact);
+    return classes;
+  }, []);
+
+/** 同じ範囲で同じ名前の拠り所の値と違う文の値は、同じ範囲の食い違い（scopeConflicts）が言う。 */
+const sameScopeAs = (fact: ScopedFact, sources: readonly ScopedFact[]): boolean => sources.some((cell) => cell.scope === fact.scope && cell.key === fact.key);
+
+/** 項目の名前を見出しにした節の範囲と、その見出し。 */
+export type TermHome = { readonly group: string; readonly heading: string; readonly start: number; readonly end: number };
+
+/** section: 拠り所が表の升でなく、項目の名前を見出しにした節のときの、その見出し。 */
+export type TermConflict = FactConflict & { readonly section?: string };
+
+const homeOf = (fact: ScopedFact, homes: readonly TermHome[]): TermHome | undefined =>
+  homes.find((home) => home.start <= fact.value.start && fact.value.start < home.end);
+
+/** 表の升があれば表だけが拠り所。項目の名前を見出しにした節の文は、表が値を書いていないときの拠り所。 */
+const sourcesOf = (facts: readonly ScopedFact[], homes: readonly TermHome[]): ScopedFact[] => {
+  const cells = facts.filter((fact) => fact.table === true);
+  return cells.length > 0 ? cells : facts.filter((fact) => homeOf(fact, homes) !== undefined);
+};
+
+/** 拠り所に表の升があれば表、無ければ最初の拠り所の節の見出し。 */
+const sectionOf = (sources: readonly ScopedFact[], homes: readonly TermHome[]): { section?: string } => {
+  if (sources.some((fact) => fact.table === true)) return {};
+  const heading = sources.map((fact) => homeOf(fact, homes)?.heading).find((written) => written !== undefined);
+  return heading === undefined ? {} : { section: heading };
+};
+
+const conflictsInClass = (facts: readonly ScopedFact[], homes: readonly TermHome[]): TermConflict[] => {
+  const sources = sourcesOf(facts, homes);
+  const [source, ...others] = distinctValues(sources.map((fact) => fact.value));
+  if (source === undefined || others.length > 0) return [];
+  if (distinctValues(facts.map((fact) => fact.value)).length !== MAX_DISTINCT) return [];
+  const section = sectionOf(sources, homes);
+  return facts
+    .filter((fact) => !sources.includes(fact) && !sameValue(source, fact.value) && !sameScopeAs(fact, sources))
+    .map((fact) => ({ fact, other: source, ...section }));
+};
+
+/** 名前の頭の冠詞（the）を落とした形。文の名前は落としてあるが、表の行の見出しは書いたまま。 */
+const withoutDeterminer = (key: string, determiners: readonly string[]): string => {
+  const [first, ...rest] = key.split(" ");
+  return rest.length > 0 && determiners.some((word) => folded(word) === first) ? rest.join(" ") : key;
+};
+
+const groupOfKey = (written: string, words: TermWords): string | undefined => {
+  const key = withoutDeterminer(written, words.determiners);
+  return words.terms.find((word) => folded(word.pattern) === key)?.group;
+};
+
+const groupOf = (fact: ScopedFact, words: TermWords): string | undefined => groupOfKey(fact.key, words);
+
+/** 書いた名前（表の列の見出し）が語彙表の項目の名前か。 */
+export const isTermName = (written: string, words: TermWords): boolean => groupOfKey(folded(written).replace(/\s+/gu, " ").trim(), words) !== undefined;
+
+export type TermSection = { readonly heading: string; readonly start: number; readonly end: number };
+
+/** 見出しが語彙表の項目の名前そのものの節（第2条（保証期間）、2. Warranty period）。 */
+export const termHomes = (sections: readonly TermSection[], words: TermWords): TermHome[] =>
+  sections.flatMap((section) => {
+    const group = groupOfKey(folded(section.heading).trim(), words);
+    return group === undefined ? [] : [{ group, heading: section.heading, start: section.start, end: section.end }];
+  });
+
+export type TermWords = { readonly terms: readonly TermWord[]; readonly determiners: readonly string[] };
+
+/**
+ * 語彙表の項目ごとに、拠り所の値と違う文の値。記録の欄（繰り返す名前）は比べない。冒頭や要約の値は、本文の値と summary-fact-mismatch
+ * が比べるので、本文の値だけを読む。
+ */
+export const documentTermConflicts = (facts: readonly ScopedFact[], words: TermWords, homes: readonly TermHome[] = []): TermConflict[] => {
+  const groups = new Map<string, ScopedFact[]>();
+  facts.forEach((fact) => {
+    const group = groupOf(fact, words);
+    if (group === undefined || fact.record || fact.part !== "body") return;
+    groups.set(group, [...(groups.get(group) ?? []), fact]);
+  });
+  return [...groups.entries()].flatMap(([group, members]) => {
+    const own = homes.filter((home) => home.group === group);
+    return comparableClasses(members).flatMap((comparableMembers) => conflictsInClass(comparableMembers, own));
+  });
+};

package/src/facts/duration-scale.ts

@@ -0,0 +1,22 @@
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+
+/**
+ * 期間を、比べられる単位に揃えた大きさ。年は月に直す（1年 と 12か月 は同じ長さ、2年 と 12か月 は違う長さ）。
+ * 月と日、週と日は直さない: 1か月 は 28〜31日で、30日 と同じとは言えない。週と日はそのまま別の単位で、比べない。
+ */
+export type ScaledDuration = { readonly key: string; readonly unit: DurationUnit };
+
+const MONTHS_PER_YEAR = 12;
+/** 0.1年 × 12 の浮動小数の端（1.2000000000000002）を落とす桁。 */
+const KEY_DIGITS = 1e6;
+
+const scaledKey = (key: string, factor: number): string | undefined => {
+  const amount = key.trim() === "" ? Number.NaN : Number(key);
+  return Number.isFinite(amount) ? String(Math.round(amount * factor * KEY_DIGITS) / KEY_DIGITS) : undefined;
+};
+
+export const scaledDuration = (key: string, unit: DurationUnit): ScaledDuration => {
+  if (unit !== "year") return { key, unit };
+  const months = scaledKey(key, MONTHS_PER_YEAR);
+  return months === undefined ? { key, unit } : { key: months, unit: "month" };
+};

package/src/facts/duration-values.ts

@@ -0,0 +1,44 @@
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import type { FactValue } from "./fact-values.ts";
+import { scaledDuration } from "./duration-scale.ts";
+
+/**
+ * 期間の値（3 months、3ヶ月間）。木の数量は、英語では数だけ（3 の後ろの months は単位として持つ）、日本語では か月 までで 間 を含まない。
+ * 値を期間の単位の語の終わりまで延ばし、単位を期間の大きさ（month）に揃える（3ヶ月 と 6か月、1 month と 6 months を比べる）。
+ * 年は月に直して比べる（1年 と 12か月）。月と日のように長さの決まらない組は、別の単位のまま。後ろに語が続く期間（3 months ago、30 years old）は、名前付きの値の
+ * 終わり（fact-value-end）で落ちる。
+ */
+export type DurationWord = { readonly pattern: string; readonly unit: DurationUnit };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const UNIT_GAPS = new Set([" ", "\t"]);
+
+/** 書いた単位の始まり。数のすぐ後ろか、空白一つの後ろ。木の値が単位まで含んでいれば、その単位の頭。 */
+const unitStartOf = (source: string, value: FactValue): number | undefined => {
+  const written = folded(value.unit);
+  if (written === "") return undefined;
+  if (folded(source.slice(value.end - value.unit.length, value.end)) === written) return value.end - value.unit.length;
+  const gap = UNIT_GAPS.has(source.charAt(value.end)) ? 1 : 0;
+  return folded(source.slice(value.end + gap, value.end + gap + value.unit.length)) === written ? value.end + gap : undefined;
+};
+
+const LATIN_LETTER = /[a-z]/iu;
+
+/** 単位の頭から書いた、一番長い期間の語（ヶ月 より ヶ月間）。英字の語は語の途中で切らない。 */
+const longestAt = (source: string, at: number, words: readonly DurationWord[]): DurationWord | undefined =>
+  words
+    .filter((word) => folded(source.slice(at, at + word.pattern.length)) === folded(word.pattern))
+    .filter((word) => !(LATIN_LETTER.test(word.pattern.slice(-1)) && LATIN_LETTER.test(source.charAt(at + word.pattern.length))))
+    .reduce<DurationWord | undefined>((longest, word) => (longest === undefined || word.pattern.length > longest.pattern.length ? word : longest), undefined);
+
+const durationOf = (source: string, value: FactValue, words: readonly DurationWord[]): FactValue[] => {
+  if (value.kind !== "quantity" || !words.some((word) => folded(word.pattern) === folded(value.unit))) return [];
+  const at = unitStartOf(source, value);
+  const word = at === undefined ? undefined : longestAt(source, at, words);
+  return at === undefined || word === undefined ? [] : [{ ...value, end: at + word.pattern.length, ...scaledDuration(value.key, word.unit) }];
+};
+
+/** 期間の単位の付いた数量だけを、単位の語まで含む期間の値にして返す。 */
+export const durationValues = (source: string, values: readonly FactValue[], words: readonly DurationWord[]): FactValue[] =>
+  values.flatMap((value) => durationOf(source, value, words));

package/src/facts/fact-values.ts

@@ -1,6 +1,7 @@
 import type { Span, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { overlapsAny, spanIndex, type SpanIndex } from "../compare/spans.ts";
+import { basesAgree, type RateBasis } from "./rate-values.ts";
 
 /**
  * 値として読むもの。木の数量と日付（`chaff compare` と同じ読み）と、品詞の読める言語では固有名詞。
@@ -8,7 +9,18 @@ import { overlapsAny, spanIndex, type SpanIndex } from "../compare/spans.ts";
  */
 export type ValueKind = "quantity" | "date" | "name";
 
-export type FactValue = Span & { readonly kind: ValueKind; readonly key: string; readonly unit: string };
+/**
+ * bound: upper なら key は上の端（満70歳まで、20 to 70 の 70）。lower は範囲の下の端（満20歳〜満70歳 の 20）。
+ * basis: 率に書いた基準（period:year、kind:fixed）。両方に書いた同じ種類の基準が違えば、別の量として比べない。
+ */
+export type FactValue = Span & {
+  readonly kind: ValueKind;
+  readonly key: string;
+  readonly unit: string;
+  readonly bound?: "upper";
+  readonly lower?: string;
+  readonly basis?: RateBasis;
+};
 
 const attr = (node: StructureNode, name: string): string => String(node.attrs[name] ?? "");
 
@@ -40,14 +52,27 @@ const nodeValue = (node: StructureNode, source: string): FactValue[] => {
 
 /**
  * 単位を書かない数（「Seats: 40」）。前後が字や数や時刻の : でないもの。1.2.3 のような版の番号は数にしない。
- * 単位の無い数は、単位の無い数とだけ比べる。
+ * 単位の無い数は、単位の無い数とだけ比べる。後ろのコンマは、空白と語が続くとき（2, as declared）だけ数の終わり。数が続けば
+ * 並べた数（2, 3 or 4）、一語の後ろに数が続けば別の値（3, or 4）で、空白が無ければ桁の区切りの書き損じかもしれない。
  */
-const BARE_NUMBER = /(?<![\p{L}\p{N}.,:/-])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?(?![\p{L}\p{N}%:/,，-]|[.．][0-9０-９])/gu;
+const BARE_NUMBER = /(?<![\p{L}\p{N}.,:/-])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?(?![\p{L}\p{N}%:/-]|[.．][0-9０-９])/gu;
+const COMMA = /^[,，]$/u;
+const CLAUSE_AFTER_COMMA = /[,，]\s+\p{L}/uy;
+const VALUE_AFTER_COMMA_WORD = /[,，]\s+\p{L}+\s+[0-9０-９]/uy;
+
+const matchesAt = (pattern: RegExp, source: string, offset: number): boolean => {
+  pattern.lastIndex = offset;
+  return pattern.test(source);
+};
+
+/** 数の後ろのコンマが、文の続き（, as declared）の頭か。コンマが無ければ終わり。 */
+const endsBeforeComma = (source: string, end: number): boolean =>
+  !COMMA.test(source.charAt(end)) || (matchesAt(CLAUSE_AFTER_COMMA, source, end) && !matchesAt(VALUE_AFTER_COMMA_WORD, source, end));
 
 const bareValues = (source: string, taken: SpanIndex): FactValue[] =>
   [...source.matchAll(BARE_NUMBER)].flatMap((match): FactValue[] => {
     const span = { start: match.index, end: match.index + match[0].length };
-    if (overlapsAny(taken, span)) return [];
+    if (!endsBeforeComma(source, span.end) || overlapsAny(taken, span)) return [];
     const key = String(Number(match[0].normalize("NFKC").replace(/,/gu, "")));
     return [{ ...span, kind: "quantity", key, unit: "" }];
   });
@@ -95,16 +120,20 @@ const comparableDates = (left: string, right: string): [string, string] | undefi
   return pair === undefined ? undefined : [pair[1], pair[0]];
 };
 
+/** 範囲は、上の端を言う値（上限か範囲）とだけ比べる。範囲の中のどれかの数（一人の年齢）とは比べない。 */
+const comparableBounds = (left: FactValue, right: FactValue): boolean =>
+  (left.lower === undefined || right.bound === "upper") && (right.lower === undefined || left.bound === "upper");
+
 /** 同じ種類の値で、比べられるもの。数量は同じ単位どうし（単位の違いは別の rule が見る）。 */
 export const comparable = (left: FactValue, right: FactValue): boolean => {
   if (left.kind !== right.kind) return false;
-  if (left.kind === "quantity") return left.unit === right.unit;
+  if (left.kind === "quantity") return left.unit === right.unit && comparableBounds(left, right) && basesAgree(left.basis, right.basis);
   return left.kind !== "date" || comparableDates(left.key, right.key) !== undefined;
 };
 
-/** 比べられる二つの値が同じか。月日だけの日付は、年まで書いた日付の月日と同じなら同じ。 */
+/** 比べられる二つの値が同じか。範囲どうしは下の端も比べる。月日だけの日付は、年まで書いた日付の月日と同じなら同じ。 */
 export const sameValue = (left: FactValue, right: FactValue): boolean => {
-  if (left.kind !== "date") return left.key === right.key;
+  if (left.kind !== "date") return left.key === right.key && (left.lower === undefined || right.lower === undefined || left.lower === right.lower);
   const pair = comparableDates(left.key, right.key);
   return pair !== undefined && pair[0] === pair[1];
 };