chaffjs 0.30.0 → 0.32.0

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/approximate-tolerance.ts

@@ -0,0 +1,19 @@
+import type { Measured, Tolerance } from "./measures.ts";
+
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+/** 目安の量（約1.2kg）が言える幅を、基準の単位で。書いた最後の桁の半分（約1.2kg は 1.15〜1.25 kg）。 */
+const writtenHalfStep = (value: Measured): number => {
+  const step = HALF * DECIMAL_BASE ** -value.decimals;
+  return step * Math.max(...value.factors);
+};
+
+/**
+ * 目安と書いた量を含む二つを比べるときの、合うとみなす差。目安の量は書いた桁までしか言っていないので、その桁の半分までの差は合う。
+ * 量の種類ごとの差（tolerance）のほうが広ければ、そちら。
+ */
+export const approximateTolerance = (tolerance: Tolerance, approximate: readonly Measured[]): Tolerance => ({
+  relative: tolerance.relative,
+  absolute: Math.max(tolerance.absolute, ...approximate.map(writtenHalfStep)),
+});

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];
 };

package/src/facts/item-amounts.ts

@@ -0,0 +1,94 @@
+import { linesOf, type Line } from "../structure/lines.ts";
+import { sameMeasure, sameUnit, type Measured } from "./measures.ts";
+import { cellsOf, tablesOf, type Cell } from "./table-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+import { toleranceOf } from "./unit-tolerance.ts";
+
+/**
+ * 表に量を書いた品物（材料の表の「しょうゆ｜大さじ1」）を、本文で違う単位の量と一緒に書いた所（しょうゆ30ml、30 ml of soy sauce）。
+ * 表の量は、行の最初の量（人数ごとの列があれば、手順が従う最初の列）。本文の量が表の量より多いときだけ言う。本文の名前は、量のすぐ前（空白一つまで）か、つなぐ語（の、of）と
+ * 冠詞（the）を挟んで量の後ろ。名前は語の切れ目で始まり終わる（「濃口しょうゆ」の しょうゆ は切れ目で始まるが、「強力粉」の 力粉 は始まらない）。
+ */
+export type ItemConflict = { readonly name: string; readonly measured: Measured; readonly other: Measured };
+
+export type ItemWords = { readonly links: readonly string[]; readonly determiners: readonly string[] };
+
+type ItemAmount = { readonly name: string; readonly key: string; readonly measured: Measured };
+
+const LETTER = /\p{L}/u;
+const SCRIPTS = [/\p{Script=Hiragana}/u, /[\p{Script=Katakana}ー]/u, /\p{Script=Han}/u, /\p{Script=Latin}/u];
+const NAME_WINDOW = 80;
+
+const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const scriptOf = (char: string): number => SCRIPTS.findIndex((script) => script.test(char));
+
+/** 二つの字の間が語の切れ目か。字でない側があるか、字の種類（仮名、漢字、英字）が変わる所。英字どうしは続いている。 */
+const isBoundary = (left: string, right: string): boolean =>
+  left === "" || right === "" || !LETTER.test(left) || !LETTER.test(right) || scriptOf(left) !== scriptOf(right);
+
+const cellValue = (cell: Cell, source: string, measured: readonly Measured[]): Measured | undefined =>
+  measured.find((value) => value.start >= cell.start && value.end <= cell.end && source.slice(value.start, value.end) === withoutEdgeMarks(cell.text));
+
+/** 表の行の見出しと、その行の最初の量。同じ名前の行が二つあれば最初の行。 */
+const tableAmounts = (source: string, rows: readonly Line[], measured: readonly Measured[]): ItemAmount[] => {
+  const amounts = rows.flatMap((row): ItemAmount[] => {
+    const [first, ...rest] = cellsOf(row);
+    const name = first === undefined ? "" : withoutEdgeMarks(first.text);
+    const value = rest.map((cell) => cellValue(cell, source, measured)).find((found) => found !== undefined);
+    if (first === undefined || value === undefined || !LETTER.test(name) || cellValue(first, source, measured) !== undefined) return [];
+    return [{ name, key: keyOf(name), measured: value }];
+  });
+  return amounts.filter((amount, index) => amounts.findIndex((other) => other.key === amount.key) === index);
+};
+
+/** 量のすぐ前に名前があるか（しょうゆ大さじ1、soy sauce 30 ml）。 */
+const namedBefore = (source: string, value: Measured, key: string): boolean => {
+  const end = source.charAt(value.start - 1) === " " ? value.start - 1 : value.start;
+  const head = keyOf(source.slice(Math.max(0, end - NAME_WINDOW), end));
+  return head.endsWith(key) && isBoundary(head.charAt(head.length - key.length - 1), key.charAt(0));
+};
+
+const skipSpace = (text: string): string => (text.startsWith(" ") ? text.slice(1) : text);
+
+/** 頭の語を一つ落とす。英字の語は、後ろに空白が要る（of は offer の頭ではない）。 */
+const dropWord = (text: string, words: readonly string[]): string | undefined => {
+  const word = words.map(keyOf).find((candidate) => text.startsWith(candidate) && isBoundary(candidate.slice(-1), text.charAt(candidate.length)));
+  return word === undefined ? undefined : skipSpace(text.slice(word.length));
+};
+
+/** つなぐ語を挟んで、量の後ろに名前があるか（30mlのしょうゆ、30 ml of the soy sauce）。 */
+const namedAfter = (source: string, value: Measured, key: string, words: ItemWords): boolean => {
+  const linked = dropWord(skipSpace(keyOf(source.slice(value.end, value.end + NAME_WINDOW))), words.links);
+  if (linked === undefined) return false;
+  const rest = dropWord(linked, words.determiners) ?? linked;
+  return rest.startsWith(key) && isBoundary(key.slice(-1), rest.charAt(key.length));
+};
+
+/** 本文の量が、表の量をどう換算しても超えるか。表より少ない量は、その一部を使う所（牛乳の半分を先に）かもしれない。 */
+const exceeds = (value: Measured, listed: Measured): boolean =>
+  value.factors.every((a) => listed.factors.every((b) => (value.amount - value.zero) * a > (listed.amount - listed.zero) * b));
+
+const inTable = (value: Measured, rows: readonly Line[]): boolean => rows.some((row) => value.start >= row.start && value.end <= row.start + row.text.length);
+
+/** 本文の量のうち、表の同じ品物の量と単位が違い、換算すると合わないもの。 */
+export const itemConflicts = (source: string, measured: readonly Measured[], words: ItemWords): ItemConflict[] => {
+  const rows = tablesOf(linesOf(source)).flatMap((table) => [table.header, ...table.rows]);
+  const amounts = tableAmounts(source, rows, measured);
+  if (amounts.length === 0) return [];
+  return measured
+    .filter((value) => !inTable(value, rows))
+    .flatMap((value): ItemConflict[] => {
+      const item = amounts.find(
+        ({ key, measured: listed }) => listed.dimension === value.dimension && (namedBefore(source, value, key) || namedAfter(source, value, key, words)),
+      );
+      if (
+        item === undefined ||
+        sameUnit(item.measured, value) ||
+        sameMeasure(item.measured, value, toleranceOf(value.dimension)) ||
+        !exceeds(value, item.measured)
+      )
+        return [];
+      return [{ name: item.name, measured: value, other: item.measured }];
+    });
+};