chaffjs 0.29.0 → 0.31.0

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

package/src/facts/labelled-facts.ts

@@ -22,9 +22,12 @@ export type FactWords = {
   /** 名前の前に置かれる決定の前置き（協議の結果、, it was decided that）。読点を含んでも条件ではないので、外してから名前を読む。 */
   readonly leads: readonly string[];
   readonly attributes: readonly AttributePhrase[];
+  /** 区切りと値のあいだに置ける目安の語（約、about）。あれば値を目安として読む。無ければ、区切りのすぐ後ろの値だけ。 */
+  readonly valueLeads?: readonly string[];
 };
 
-export type Fact = { readonly label: string; readonly key: string; readonly value: FactValue };
+/** approximate: 値の前に目安の語（約、about）があった。 */
+export type Fact = { readonly label: string; readonly key: string; readonly value: FactValue; readonly approximate?: boolean };
 
 const MAX_LABEL_LENGTH = 24;
 const MAX_LABEL_WORDS = 5;
@@ -57,6 +60,15 @@ const beforeSeparator = (head: string, separator: string): string | undefined =>
   return rest;
 };
 
+/** 頭の後ろの目安の語（「重さは約」の約、"is about" の about）を外したもの。英字の語は、前が語の切れ目のときだけ。 */
+const withoutValueLead = (head: string, leads: readonly string[]): string => {
+  const lowered = head.toLowerCase();
+  const lead = leads.find(
+    (word) => lowered.endsWith(word.toLowerCase()) && !(LATIN_LETTER.test(word.charAt(0)) && LATIN_LETTER.test(head.charAt(head.length - word.length - 1))),
+  );
+  return lead === undefined ? head : trimEndOf(head.slice(0, head.length - lead.length), EDGE_MARKS);
+};
+
 /** 英字の前置きが語の途中で切れているか（「we agreed that」は「we agreed thatching」の頭ではない）。 */
 const endsInsideWord = (text: string, length: number): boolean => LATIN_LETTER.test(text.charAt(length - 1)) && LATIN_LETTER.test(text.charAt(length));
 
@@ -75,11 +87,18 @@ const afterLastBreak = (text: string): string => {
 
 const wordsOf = (text: string): string[] => text.split(/\s+/u).filter((word) => word !== "");
 
+/** 語を空白で分けない言語の、名前の頭の前置き（「本体の幅」の 本体の）。前置きだけの名前は落とさない。 */
+const withoutPrefix = (key: string, determiners: readonly string[]): string => {
+  const prefix = determiners.find((word) => !LATIN_WORD.test(word) && key.length > word.length && key.startsWith(word));
+  return prefix === undefined ? key : key.slice(prefix.length);
+};
+
 /** 名前を一つの書き方に。全角と半角、大文字と小文字、空白の数を揃え、頭の冠詞を落とす。 */
 const keyOf = (label: string, words: FactWords): string => {
   const [first, ...rest] = wordsOf(label.normalize("NFKC").toLowerCase());
-  const determiners = new Set(words.determiners.map((word) => word.toLowerCase()));
-  return (first !== undefined && determiners.has(first) ? rest : [first ?? "", ...rest]).join(" ");
+  const determiners = words.determiners.map((word) => word.normalize("NFKC").toLowerCase());
+  const key = (first !== undefined && determiners.includes(first) ? rest : [first ?? "", ...rest]).join(" ");
+  return withoutPrefix(key, determiners);
 };
 
 const containsSeparator = (label: string, words: FactWords): boolean =>
@@ -98,14 +117,17 @@ const isLabel = (label: string, key: string, words: FactWords): boolean =>
   !words.vague.some((word) => word.toLowerCase() === key);
 
 /** 値の後ろが文の切れ目か。行の終わり、表の升の終わり、語彙表の終わりの語。 */
+/** 値の後ろが文の切れ目か。行の終わり、表の升の終わり、語彙表の終わりの語。半角の数のまわりに空白を置く書き方（「14 cm です」）もある。 */
 const endsAfter = (source: string, value: FactValue, words: FactWords): boolean => {
-  const after = source.slice(value.end, lineEndOf(source, value.end)).replace(MARKS_AFTER_VALUE, "");
-  if (after.trim() === "" || after.trimStart().startsWith("|")) return true;
+  const after = source.slice(value.end, lineEndOf(source, value.end)).replace(MARKS_AFTER_VALUE, "").trimStart();
+  if (after === "" || after.startsWith("|")) return true;
   return words.valueEnds.some((end) => after.startsWith(end));
 };
 
 const labelledFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
-  const head = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS);
+  const written = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS);
+  const head = withoutValueLead(written, words.valueLeads ?? []);
+  const approximate = head.length < written.length ? { approximate: true } : {};
   for (const separator of words.separators) {
     const before = beforeSeparator(head, separator);
     if (before === undefined) continue;
@@ -113,7 +135,7 @@ const labelledFact = (source: string, value: FactValue, words: FactWords): Fact
     if (CLAUSE_COMMA.test(clause)) return undefined;
     const label = withoutEdgeMarks(clause);
     const key = keyOf(label, words);
-    return isLabel(label, key, words) ? { label, key, value } : undefined;
+    return isLabel(label, key, words) ? { label, key, value, ...approximate } : undefined;
   }
   return undefined;
 };

package/src/facts/measure-units.ts

@@ -0,0 +1,31 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { MeasureUnit } from "./measures.ts";
+
+/** 量の種類ごとの語彙表。weight が基準の単位への倍率で、同じ単位を二度書けば倍率が二つ（GB の 10^9 と 2^30）。 */
+const MEASURE_DIMENSIONS = ["unit-length", "unit-mass", "unit-time", "unit-volume", "unit-data", "unit-temperature", "unit-pressure", "unit-area"] as const;
+
+const unitKey = (pattern: string, before: boolean): string => `${before ? "<" : ">"}${pattern}`;
+
+/** 単位ごとの、零点（unit-zero）と、要る文脈の語（unit-context の group がその単位の語）。 */
+export const measureUnitsOf = (doc: ProseDocument): MeasureUnit[] => {
+  const zeros = new Map((doc.lexicons["unit-zero"] ?? []).map((entry) => [entry.pattern, entry.weight ?? 0]));
+  const contexts = doc.lexicons["unit-context"] ?? [];
+  return MEASURE_DIMENSIONS.flatMap((dimension) => {
+    const factors = new Map<string, { pattern: string; before: boolean; weights: number[] }>();
+    (doc.lexicons[dimension] ?? []).forEach((entry) => {
+      if (entry.weight === undefined) return;
+      const before = entry.position === "before";
+      const key = unitKey(entry.pattern, before);
+      const found = factors.get(key) ?? { pattern: entry.pattern, before, weights: [] };
+      factors.set(key, { ...found, weights: [...found.weights, entry.weight] });
+    });
+    return [...factors.values()].map(({ pattern, before, weights }) => ({
+      pattern,
+      dimension,
+      factors: weights,
+      zero: zeros.get(pattern) ?? 0,
+      before,
+      context: contexts.filter((entry) => entry.group === pattern).map((entry) => entry.pattern),
+    }));
+  });
+};

package/src/facts/measures.ts

@@ -1,54 +1,142 @@
 import type { FactValue } from "./fact-values.ts";
+import { lineHasContext, standsAsUnitWord } from "./unit-word.ts";
 
 /**
- * 単位の付いた量（5 km、3000 m、1.5時間、2 GB）。単位は言語パッケージの語彙表から取り、量の種類（長さ、重さ…）と、基準の単位への
- * 倍率を持つ。倍率が二つある単位（1 GB は 10^9 か 2^30 バイト）は、どちらで数えても合えば合う。
+ * 単位の付いた量（5 km、3000 m、1.5時間、2 GB、180℃、大さじ1）。単位は言語パッケージの語彙表から取り、量の種類（長さ、重さ…）と、基準の単位への
+ * 倍率を持つ。倍率が二つある単位（1 GB は 10^9 か 2^30 バイト）は、どちらで数えても合えば合う。零点がずれた単位（°F）は zero を引いてから掛ける。
  */
-export type MeasureUnit = { readonly pattern: string; readonly dimension: string; readonly factors: readonly number[] };
+export type MeasureUnit = {
+  readonly pattern: string;
+  readonly dimension: string;
+  readonly factors: readonly number[];
+  /** 基準の単位で 0 のときに、この単位で読む値（°F なら 32）。 */
+  readonly zero: number;
+  /** 数の前に書く単位（大さじ1）。 */
+  readonly before: boolean;
+  /** 同じ行にどれかが無ければ単位として読まない語（「度」はオーブンの行だけ温度）。空なら要らない。 */
+  readonly context: readonly string[];
+};
 
-export type Measured = FactValue & { readonly dimension: string; readonly factors: readonly number[]; readonly amount: number };
+export type Measured = FactValue & {
+  readonly dimension: string;
+  readonly factors: readonly number[];
+  readonly zero: number;
+  readonly amount: number;
+  /** 書いた小数の桁数（1.20 なら 2）。amount は数なので末尾の 0 を持たない。 */
+  readonly decimals: number;
+};
 
-/** 前に英字や数が続く数（v2、A4、1.2.3 の 2）は量ではない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
-const NUMBER = /(?<![\p{Script=Latin}\p{N}.,])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+/** 換算して合うとみなす差。relative は大きいほうの値に対する割合、absolute は基準の単位での差。どちらかに収まれば合う。 */
+export type Tolerance = { readonly relative: number; readonly absolute: number };
 
 /**
- * 数のすぐ後ろ（空白一つまで）の単位。長い単位から試す（「5分間」を 分 で切らない、min を m にしない）。
+ * 前に英字や数が続く数（v2、A4、1.2.3 の 2）と、分数の分母（1/2 の 2）は量ではない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。
+ * 字や数のすぐ後ろでない負の符号は数に含める（-20 °C）。20-25°C の - は範囲の印。
+ */
+const NUMBER = /(?<![\p{Script=Latin}\p{N}.,])(?<![0-9０-９][/／])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+const MINUS_SIGNS = new Set(["-", "−", "－"]);
+const BEFORE_SIGN = /[\p{L}\p{N}.,]/u;
+
+/** 数の頭の負の符号の位置。符号が無ければ数の頭。 */
+const signedStart = (source: string, start: number): number =>
+  MINUS_SIGNS.has(source.charAt(start - 1)) && !BEFORE_SIGN.test(source.charAt(start - 2)) ? start - 1 : start;
+
+/** 数のすぐ後ろに分数が続く（大さじ1と1/2、1 1/2 cups、1½）。数だけを読むと量を取り違える。 */
+const FRACTION_AFTER = /^.?[0-9０-９]*[/／][0-9０-９]|^.?[½⅓⅔¼¾⅛]/u;
+
+const MAX_UNIT_LENGTH = 20;
+
+const lineAt = (source: string, offset: number): string => {
+  const end = source.indexOf("\n", offset);
+  return source.slice(source.lastIndexOf("\n", offset - 1) + 1, end === -1 ? source.length : end);
+};
+
+const inContext = (unit: MeasureUnit, source: string, offset: number): boolean =>
+  unit.context.length === 0 || lineHasContext(lineAt(source, offset), unit.context);
+
+/** 数と単位のあいだに置ける字。空白一つか、英語の複合語のハイフン（13.3-inch display）。 */
+const GAPS = new Set([" ", "-"]);
+
+type Found = { readonly unit: MeasureUnit; readonly start: number; readonly end: number };
+
+/**
+ * 数のすぐ後ろ（空白かハイフン一つまで）の単位。長い単位から試す（「5分間」を 分 で切らない、min を m にしない）。
  * 単位の後ろに語が続く（5 miners）ものは、名前付きの値の終わり（fact-value-end）で落ちるので、ここでは見ない。
  */
-const unitAfter = (source: string, end: number, units: readonly MeasureUnit[]): { unit: MeasureUnit; end: number } | undefined => {
-  const gap = source.charAt(end) === " " ? 1 : 0;
-  const rest = source.slice(end + gap, end + gap + 16);
-  const unit = units.find((candidate) => rest.startsWith(candidate.pattern));
-  return unit === undefined ? undefined : { unit, end: end + gap + unit.pattern.length };
+const unitAfter = (source: string, start: number, end: number, units: readonly MeasureUnit[]): Found | undefined => {
+  const gap = GAPS.has(source.charAt(end)) ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + MAX_UNIT_LENGTH);
+  const unit = units.find(
+    (candidate) =>
+      !candidate.before &&
+      rest.startsWith(candidate.pattern) &&
+      standsAsUnitWord(candidate.pattern, candidate.context.length > 0, source.slice(end + gap + candidate.pattern.length)) &&
+      inContext(candidate, source, end),
+  );
+  return unit === undefined ? undefined : { unit, start, end: end + gap + unit.pattern.length };
+};
+
+/** 数のすぐ前（空白一つまで）の単位（大さじ1）。 */
+const unitBefore = (source: string, start: number, end: number, units: readonly MeasureUnit[]): Found | undefined => {
+  const gap = source.charAt(start - 1) === " " ? 1 : 0;
+  const head = source.slice(Math.max(0, start - gap - MAX_UNIT_LENGTH), start - gap);
+  const unit = units.find((candidate) => candidate.before && head.endsWith(candidate.pattern) && inContext(candidate, source, start));
+  return unit === undefined ? undefined : { unit, start: start - gap - unit.pattern.length, end };
 };
 
 /** 文書の中の、単位の付いた量。 */
 export const measuredValues = (source: string, units: readonly MeasureUnit[]): Measured[] => {
   const longestFirst = units.toSorted((left, right) => right.pattern.length - left.pattern.length);
   return [...source.matchAll(NUMBER)].flatMap((match): Measured[] => {
-    const found = unitAfter(source, match.index + match[0].length, longestFirst);
+    const end = match.index + match[0].length;
+    if (FRACTION_AFTER.test(source.slice(end, end + MAX_UNIT_LENGTH))) return [];
+    const start = signedStart(source, match.index);
+    const found = unitAfter(source, start, end, longestFirst) ?? unitBefore(source, start, end, longestFirst);
     if (found === undefined) return [];
-    const amount = Number(match[0].normalize("NFKC").replace(/,/gu, ""));
+    const written = match[0].normalize("NFKC").replace(/,/gu, "");
+    const magnitude = Number(written);
+    const amount = start < match.index ? -magnitude : magnitude;
+    const { unit } = found;
     return [
       {
-        start: match.index,
+        start: found.start,
         end: found.end,
         kind: "quantity",
         key: String(amount),
-        unit: found.unit.pattern,
-        dimension: found.unit.dimension,
-        factors: found.unit.factors,
+        unit: unit.pattern,
+        dimension: unit.dimension,
+        factors: unit.factors,
+        zero: unit.zero,
         amount,
+        decimals: written.split(".")[1]?.length ?? 0,
       },
     ];
   });
 };
 
-/** 二つの量が同じ量か。倍率のどの組み合わせかで、基準の単位に直した値の差が大きいほうの tolerance 以内なら同じ。 */
-export const sameMeasure = (left: Measured, right: Measured, tolerance: number): boolean =>
-  left.factors.some((a) =>
-    right.factors.some((b) => {
-      const [x, y] = [left.amount * a, right.amount * b];
-      return Math.abs(x - y) <= Math.max(Math.abs(x), Math.abs(y)) * tolerance;
-    }),
+/** 二つの量の単位が、書き方だけ違う同じ単位か（mL と ml、tablespoon と tablespoons）。 */
+export const sameUnit = (left: Measured, right: Measured): boolean =>
+  left.zero === right.zero && left.factors.length === right.factors.length && left.factors.every((factor, index) => factor === right.factors[index]);
+
+const agrees = (x: number, y: number, tolerance: Tolerance): boolean => {
+  const difference = Math.abs(x - y);
+  return difference <= tolerance.absolute || difference <= Math.max(Math.abs(x), Math.abs(y)) * tolerance.relative;
+};
+
+/** 零点のずれた単位で、零点より小さい量（1 °F）。温度の読みより、差（0.5 ℃ の上昇は 0.9 °F）のことが多い。 */
+const couldBeDifference = (value: Measured): boolean => value.zero !== 0 && Math.abs(value.amount) < Math.abs(value.zero);
+
+/**
+ * 二つの量が同じ量か。倍率のどの組み合わせかで、基準の単位に直した値の差が tolerance に収まれば同じ。零点より小さい °F の量は、差として
+ * 零点を引かずに直しても合えば合う（0.5°C (1°F)）。180 °F は差としては読まないので、100 °C (180 °F) は合わない。
+ */
+export const sameMeasure = (left: Measured, right: Measured, tolerance: Tolerance): boolean => {
+  const difference = couldBeDifference(left) || couldBeDifference(right);
+  return left.factors.some((a) =>
+    right.factors.some(
+      (b) =>
+        agrees((left.amount - left.zero) * a, (right.amount - right.zero) * b, tolerance) ||
+        (difference && agrees(left.amount * a, right.amount * b, tolerance)),
+    ),
   );
+};

package/src/facts/retention-periods.ts

@@ -0,0 +1,216 @@
+import type { Span, Token } from "../plugin.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+
+/**
+ * 保存期間。文が、保存の語（保存、keep）か、期間の後に消す語（3年間を経過した…を削除、delete … 3 years after）と、期間を
+ * 一つだけ持つとき、その期間を、語の前後の名詞句（個人情報、personal information）の保存期間と読む。文書のどこでも、同じ名詞句に
+ * 違う長さが二通り書かれていれば言う。名詞句が違えば別のもの（ログは90日、アカウントの情報は1年）。
+ * 上限や下限や目安の長さ（最長、以上、約、up to、at least）は範囲なので比べない。年と月、週と日だけを換算して比べる。
+ */
+export type RetentionLength = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+/** position: 対象の名詞句が語の前か後ろか。後ろなら、後ろに無いとき前を読む（is retained の受け身）。 */
+export type RetentionVerb = { readonly pattern: string; readonly group: string; readonly position: "before" | "after" };
+
+/** その組の語が期間を言うのに、期間の前か後ろに要る語（keep … for、delete … after、経過）。組に語が無ければ要らない。 */
+export type LengthMark = { readonly pattern: string; readonly group: string; readonly position: "before" | "after" };
+
+export type WordAt = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type RetentionWords = {
+  readonly verbs: readonly RetentionVerb[];
+  readonly marks: readonly LengthMark[];
+  /** 期間のすぐ後ろにあれば、期間が名詞を修飾している（過去3年間の記録）。 */
+  readonly modifiers: readonly string[];
+  /** 範囲や目安の印（最長、以上、up to）。 */
+  readonly bounds: readonly WordAt[];
+  /** 名詞句の中で名詞をつなぐ語（お問い合わせの記録 の の）。 */
+  readonly joiners: readonly string[];
+  /** 名詞句と、前にある保存の語のあいだの語（を、は）。無い言語は名詞句がすぐ前。 */
+  readonly objectMarks: readonly string[];
+};
+
+export type RetentionSentence = Span & { readonly tokens: readonly Token[] };
+
+export type RetentionConflict = { readonly object: string; readonly value: RetentionLength; readonly other: RetentionLength };
+
+type Statement = { readonly object: string; readonly length: RetentionLength; readonly base: string; readonly count: number };
+
+const NOUN_PHRASE = new Set(["NOUN", "PROPN", "ADJ"]);
+const SKIPPED_BEFORE = new Set(["PUNCT", "AUX", "ADV", "VERB", "PART"]);
+const DROPPED = new Set(["DET", "PRON"]);
+
+const MONTHS_PER_YEAR = 12;
+const DAYS_PER_WEEK = 7;
+
+const scaled: Readonly<Record<DurationUnit, readonly [string, number]>> = {
+  year: ["month", MONTHS_PER_YEAR],
+  month: ["month", 1],
+  week: ["day", DAYS_PER_WEEK],
+  day: ["day", 1],
+};
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const LATIN = /[a-z]/u;
+
+/** 英字の語は語として（for は form の頭ではない）。 */
+const isWordAt = (text: string, at: number, word: string): boolean =>
+  text.startsWith(word, at) &&
+  !(LATIN.test(word.charAt(0)) && LATIN.test(text.charAt(at - 1))) &&
+  !(LATIN.test(word.slice(-1)) && LATIN.test(text.charAt(at + word.length)));
+
+const NEAR = 24;
+
+const before = (source: string, span: Span): string => folded(source.slice(Math.max(0, span.start - NEAR), span.start)).trimEnd();
+const after = (source: string, span: Span): string => folded(source.slice(span.end, span.end + NEAR)).trimStart();
+
+const endsWithWord = (text: string, word: string): boolean => {
+  const pattern = folded(word);
+  return isWordAt(text, text.length - pattern.length, pattern);
+};
+
+const startsWithWord = (text: string, word: string): boolean => isWordAt(text, 0, folded(word));
+
+const besideLength = (source: string, length: Span, word: WordAt): boolean =>
+  word.position === "before" ? endsWithWord(before(source, length), word.pattern) : startsWithWord(after(source, length), word.pattern);
+
+const CLAUSE_COMMA = /^[,、，]\s*/u;
+
+/** 後ろの印は読点の後でもよい（90 days, or longer）。 */
+const isBounded = (source: string, length: Span, words: RetentionWords): boolean =>
+  words.bounds.some(
+    (word) =>
+      besideLength(source, length, word) || (word.position === "after" && startsWithWord(after(source, length).replace(CLAUSE_COMMA, ""), word.pattern)),
+  );
+
+/** 期間の後ろの印（3年後に、を経過）の終わり。印の語は名詞句ではないので、名詞句を探すとき期間と一緒に飛ばす。 */
+const endWithMark = (source: string, length: Span, group: string, words: RetentionWords): number => {
+  const gap = /^\s*/u.exec(source.slice(length.end, length.end + NEAR))?.[0].length ?? 0;
+  const written = words.marks
+    .filter((mark) => mark.group === group && mark.position === "after" && besideLength(source, length, mark))
+    .reduce((longest, mark) => Math.max(longest, mark.pattern.length), 0);
+  return written === 0 ? length.end : length.end + gap + written;
+};
+
+const tokenWord = (token: Token): string => folded(token.lemma ?? token.surface);
+
+const isVerbToken = (token: Token, verb: RetentionVerb): boolean => tokenWord(token) === folded(verb.pattern) || folded(token.surface) === folded(verb.pattern);
+
+/** 組の語に印が要らないか、要る印が期間の前後にある。 */
+const marked = (source: string, length: Span, group: string, words: RetentionWords): boolean => {
+  const marks = words.marks.filter((mark) => mark.group === group);
+  return marks.length === 0 || marks.some((mark) => besideLength(source, length, mark));
+};
+
+type VerbAt = { readonly verb: RetentionVerb; readonly index: number; readonly token: Token };
+
+const verbsIn = (tokens: readonly Token[], verbs: readonly RetentionVerb[]): VerbAt[] =>
+  tokens.flatMap((token, index) => verbs.filter((verb) => isVerbToken(token, verb)).map((verb) => ({ verb, index, token })));
+
+const inside = (outer: Span, inner: Span): boolean => outer.start <= inner.start && inner.end <= outer.end;
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+const isPhraseToken = (token: Token | undefined, length: Span): boolean => token !== undefined && NOUN_PHRASE.has(token.pos) && !overlaps(token.span, length);
+
+const isJoiner = (token: Token | undefined, words: RetentionWords): boolean =>
+  token !== undefined && words.joiners.some((joiner) => folded(joiner) === folded(token.surface));
+
+/** index から前へ、名詞句の始まり。つなぐ語の前の名詞も句に入れる（お問い合わせ の 記録）。 */
+const phraseStart = (tokens: readonly Token[], index: number, length: Span, words: RetentionWords): number => {
+  let start = index;
+  while (start > 0) {
+    const previous = tokens[start - 1];
+    if (isPhraseToken(previous, length)) start -= 1;
+    else if (isJoiner(previous, words) && isPhraseToken(tokens[start - 2], length)) start -= 2;
+    else break;
+  }
+  return start;
+};
+
+/** index から後ろへ、名詞句の終わり（含まない）。 */
+const phraseEnd = (tokens: readonly Token[], index: number, length: Span, words: RetentionWords): number => {
+  let end = index;
+  while (end < tokens.length) {
+    const next = tokens[end];
+    if (isPhraseToken(next, length)) end += 1;
+    else if (isJoiner(next, words) && isPhraseToken(tokens[end + 1], length)) end += 2;
+    else break;
+  }
+  return end;
+};
+
+const phraseKey = (tokens: readonly Token[]): string => tokens.map(tokenWord).join(tokens.some((token) => LATIN.test(folded(token.surface))) ? " " : "");
+
+/** 語の後ろの名詞句（keep your personal information）。冠詞や代名詞は飛ばす。 */
+const objectAfter = (tokens: readonly Token[], index: number, length: Span, words: RetentionWords): string => {
+  let start = index + 1;
+  while (DROPPED.has(tokens[start]?.pos ?? "")) start += 1;
+  return phraseKey(tokens.slice(start, phraseEnd(tokens, start, length, words)));
+};
+
+const isObjectMark = (token: Token, words: RetentionWords): boolean => words.objectMarks.some((mark) => folded(mark) === folded(token.surface));
+
+/** 語の前の名詞句（個人情報を…保存、Account data is retained）。期間と句読点と助動詞は飛ばし、印のある言語は印の前。 */
+const objectBefore = (tokens: readonly Token[], index: number, length: Span, words: RetentionWords): string => {
+  let end = index;
+  const skipped = (token: Token | undefined): boolean => token !== undefined && (overlaps(token.span, length) || SKIPPED_BEFORE.has(token.pos));
+  while (end > 0 && skipped(tokens[end - 1])) end -= 1;
+  if (words.objectMarks.length > 0) {
+    const mark = tokens[end - 1];
+    if (mark === undefined || !isObjectMark(mark, words)) return "";
+    end -= 1;
+  }
+  if (!isPhraseToken(tokens[end - 1], length)) return "";
+  return phraseKey(tokens.slice(phraseStart(tokens, end - 1, length, words), end));
+};
+
+const objectOf = (tokens: readonly Token[], at: VerbAt, length: Span, words: RetentionWords): string => {
+  const following = at.verb.position === "after" ? objectAfter(tokens, at.index, length, words) : "";
+  return following === "" ? objectBefore(tokens, at.index, length, words) : following;
+};
+
+const distance = (token: Token, length: Span): number => Math.abs(token.span.start - length.start);
+
+/** 文の保存期間の言い方。期間がちょうど一つ、印の揃った組がちょうど一つのときだけ。 */
+const statementOf = (source: string, sentence: RetentionSentence, lengths: readonly RetentionLength[], words: RetentionWords): Statement[] => {
+  const own = lengths.filter((length) => inside(sentence, length));
+  const [length] = own;
+  if (own.length !== 1 || length === undefined || isBounded(source, length, words)) return [];
+  if (words.modifiers.some((word) => startsWithWord(after(source, length), word))) return [];
+  const verbs = verbsIn(sentence.tokens, words.verbs).filter((at) => marked(source, length, at.verb.group, words));
+  if (new Set(verbs.map((at) => at.verb.group)).size !== 1) return [];
+  const [nearest] = verbs.toSorted((left, right) => distance(left.token, length) - distance(right.token, length));
+  if (nearest === undefined) return [];
+  const object = objectOf(sentence.tokens, nearest, { start: length.start, end: endWithMark(source, length, nearest.verb.group, words) }, words);
+  const [base, factor] = scaled[length.unit];
+  return object === "" ? [] : [{ object, length, base, count: length.amount * factor }];
+};
+
+const conflictsOf = (statements: readonly Statement[]): RetentionConflict[] => {
+  const [first] = statements;
+  if (first === undefined) return [];
+  const counts = new Set(statements.map((statement) => statement.count));
+  if (counts.size !== 2) return [];
+  return statements
+    .filter((statement) => statement.count !== first.count)
+    .map((statement) => ({ object: statement.object, value: statement.length, other: first.length }));
+};
+
+const groupedBy = (statements: readonly Statement[]): Statement[][] => [
+  ...statements
+    .reduce((groups, statement) => {
+      const key = `${statement.object}\u0000${statement.base}`;
+      groups.set(key, [...(groups.get(key) ?? []), statement]);
+      return groups;
+    }, new Map<string, Statement[]>())
+    .values(),
+];
+
+/** 同じ名詞句の保存期間が二通り。三通り以上は一覧として言わない。lengths は期間の単位を持つ数量だけ。 */
+export const retentionConflicts = (
+  source: string,
+  sentences: readonly RetentionSentence[],
+  lengths: readonly RetentionLength[],
+  words: RetentionWords,
+): RetentionConflict[] => groupedBy(sentences.flatMap((sentence) => statementOf(source, sentence, lengths, words))).flatMap(conflictsOf);

package/src/facts/table-facts.ts

@@ -69,3 +69,6 @@ export const tableFacts = (source: string, values: readonly FactValue[]): Fact[]
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
     return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
   });
+
+/** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */
+export const tableBodyCells = (source: string): Cell[] => tablesOf(linesOf(source)).flatMap((table) => table.rows.flatMap(cellsOf));