chaffjs 0.31.0 → 0.32.0

package/src/facts/table-facts.ts

@@ -5,11 +5,12 @@ import { CELL_SEPARATOR } from "../structure/bare-numbers.ts";
 import type { FactValue } from "./fact-values.ts";
 import type { Fact } from "./labelled-facts.ts";
 import { withoutEdgeMarks } from "./trim-marks.ts";
+import { isCountLabelHead, type CountLabelWords } from "./count-labels.ts";
 
 /**
  * 表の升の値。名前は行の見出し（最初の列）で、列が三つ以上なら列の見出しも付ける（「大人 料金」）。
  * 升に値だけを書いたときだけ読む。「3,000円（税込）」のように条件を書いた升は読まない。
- * 行の見出しが値を含むか字を含まない表（日付の列から始まる日程表）は、行に名前が無いので読まない。
+ * 行の見出しが値を含むか字を含まない表（日付の列から始まる日程表）は、行に名前が無いので読まない。頭の数えた数（「1箱の重さ」の 1箱）は名前の一部。
  */
 export type Cell = Span & { readonly text: string };
 
@@ -49,25 +50,52 @@ const cellValue = (cell: Cell, values: readonly FactValue[], source: string): Fa
 
 const keyOf = (label: string): string => label.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
 
-const rowFacts = (row: Line, headings: readonly string[], values: readonly FactValue[], source: string): Fact[] => {
+/**
+ * 合計の行の見分け方と、文書全体で一つの値を持つ項目の名前。合計の行（| 合計 | 5箱 |）の、列の見出しがその項目の名前（箱数）の升は、
+ * 列の見出しだけを名前にする: 列の合計が文書の値。ほかの行の升は、行の名前が付いた別の名前のまま。
+ */
+export type TotalColumns = { readonly labels: readonly string[]; readonly isTerm: (heading: string) => boolean };
+
+const isTotalRow = (rowLabel: string, totals: TotalColumns | undefined): boolean =>
+  totals !== undefined && totals.labels.some((label) => keyOf(label) === keyOf(rowLabel));
+
+const cellLabel = (rowLabel: string, column: string, headings: readonly string[], total: boolean, totals: TotalColumns | undefined): string => {
+  if (total && totals?.isTerm(column) === true) return column;
+  return headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
+};
+
+/** 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。 */
+export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string } };
+
+const rowFacts = (
+  row: Line,
+  headings: readonly string[],
+  values: readonly FactValue[],
+  source: string,
+  totals?: TotalColumns,
+  counts?: CountLabelWords,
+): TableFact[] => {
   const [first, ...rest] = cellsOf(row);
   if (first === undefined) return [];
   const rowLabel = plain(first.text);
-  if (!LETTER.test(rowLabel) || values.some((value) => inside(first, value))) return [];
+  const isCountHead = (value: FactValue): boolean => counts !== undefined && isCountLabelHead(source, first, value, counts);
+  if (!LETTER.test(rowLabel) || values.some((value) => inside(first, value) && !isCountHead(value))) return [];
+  const total = isTotalRow(rowLabel, totals);
   return rest.flatMap((cell, index) => {
     const value = cellValue(cell, values, source);
     const column = headings[index + 1] ?? "";
     if (value === undefined || (headings.length > TWO_COLUMNS && column === "")) return [];
-    const label = headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
-    return [{ label, key: keyOf(label), value }];
+    const label = cellLabel(rowLabel, column, headings, total, totals);
+    const parts = label === column || headings.length <= TWO_COLUMNS ? {} : { cell: { row: rowLabel, column } };
+    return [{ label, key: keyOf(label), value, table: true, ...parts }];
   });
 };
 
 /** 文書の表すべての升の値。 */
-export const tableFacts = (source: string, values: readonly FactValue[]): Fact[] =>
+export const tableFacts = (source: string, values: readonly FactValue[], totals?: TotalColumns, counts?: CountLabelWords): TableFact[] =>
   tablesOf(linesOf(source)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
-    return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
+    return table.rows.flatMap((row) => rowFacts(row, headings, values, source, totals, counts));
   });
 
 /** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */

package/src/facts/term-values.ts

@@ -0,0 +1,236 @@
+import { sameValue, type FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+import type { TermWord } from "./document-terms.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 文書全体で一つの値を持つ項目（保証期間、warranty period）を主語にした文の期間。名前付きの値の読み（labelled-facts）は、区切りの
+ * すぐ後ろで文が終わる値だけを読むので、起算の句の付いた値（「保証期間は、お買い上げ日から24か月です」"The warranty period is
+ * 24 months from the date of purchase"）と、名前の後ろの括弧の値（「保証期間（12か月）のうち」）はここで読む。語彙表の名前が主語
+ * のときだけ読む: 「無料交換期間は、お買い上げ日から18か月です」は主語が違う。前に条件の句がある文（「製品登録をされた場合、」）は
+ * 読まない。条件の句が起算の日付だけを書いた例（「お買い上げ日が2026年7月1日の場合、保証期間は2026年7月1日から12か月」）は読む:
+ * 起算の日を決めるだけで、長さを変えない。
+ */
+export type PlacedWord = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type TermValueWords = {
+  readonly terms: readonly TermWord[];
+  /** 名前と値の区切り（は、is）と、項目の長さを言う動詞（runs for、lasts）。 */
+  readonly separators: readonly string[];
+  /** 名前の頭から落とす語（the、本体の）。 */
+  readonly determiners: readonly string[];
+  /** 文書が説明しているもの自身を指す、名前に付いた語（本製品の、for the product）。付いていても同じ項目。 */
+  readonly selves: readonly PlacedWord[];
+  /** 起算の句の印（から は値の前の句の終わり、from は値の後ろの句の頭）。 */
+  readonly starts: readonly PlacedWord[];
+  readonly valueEnds: readonly string[];
+};
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const SENTENCE_BREAK = /[。！？!?|．]|\.(?=\s)/gu;
+const BLOCK_MARK = /^[ \t]*(?:#{1,6}[ \t]+|>[ \t]?)?/u;
+const ITEM_MARK = /^[-*+][ \t]+/u;
+const CLAUSE_COMMAS = /[、，,]/gu;
+const CLAUSE_COMMA = /[、，,]/u;
+const LATIN_WORD = /^[a-z ]+$/iu;
+const OPEN_BRACKETS = ["（", "("];
+const CLOSE_BRACKETS = ["）", ")"];
+/** 起算の句の長さの上限。長い句は、ほかの条件を含むことがある。 */
+const MAX_START_PHRASE = 32;
+const PHRASE_STOPS = new Set([".", ",", ";", "(", "（", "、", "。"]);
+
+const lineStartOf = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const lineEndOf = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+/** 値の前の、文の頭からの位置。 */
+export const clauseStartOf = (source: string, offset: number): number => {
+  const lineStart = lineStartOf(source, offset);
+  const breaks = [...source.slice(lineStart, offset).matchAll(SENTENCE_BREAK)];
+  const last = breaks.at(-1);
+  const start = last === undefined ? lineStart : lineStart + last.index + last[0].length;
+  const block = BLOCK_MARK.exec(source.slice(start, offset))?.[0].length ?? 0;
+  const item = ITEM_MARK.exec(source.slice(start + block, offset))?.[0].length ?? 0;
+  return start + block + item;
+};
+
+const withoutDeterminer = (key: string, words: TermValueWords): string => {
+  const [first, ...rest] = key.split(" ");
+  const latin = words.determiners.map(folded).filter((word) => LATIN_WORD.test(word));
+  if (rest.length > 0 && latin.includes(first ?? "")) return rest.join(" ");
+  const prefix = words.determiners.map(folded).find((word) => !LATIN_WORD.test(word) && key.length > word.length && key.startsWith(word));
+  return prefix === undefined ? key : key.slice(prefix.length);
+};
+
+const withoutSelf = (key: string, words: TermValueWords): string => {
+  const self = words.selves.find((word) => (word.position === "before" ? key.startsWith(folded(word.pattern)) : key.endsWith(` ${folded(word.pattern)}`)));
+  if (self === undefined) return key;
+  const length = folded(self.pattern).length;
+  return (self.position === "before" ? key.slice(length) : key.slice(0, key.length - length)).trim();
+};
+
+/** 名前が語彙表の項目なら、その語の形。 */
+export const termKeyOf = (label: string, words: TermValueWords): string | undefined => {
+  const key = withoutSelf(withoutDeterminer(folded(withoutEdgeMarks(label)), words), words);
+  return words.terms.map((word) => folded(word.pattern)).find((pattern) => pattern === key);
+};
+
+type Span = { readonly start: number; readonly end: number };
+
+const valuesIn = (values: readonly FactValue[], span: Span): FactValue[] => values.filter((value) => span.start <= value.start && value.end <= span.end);
+
+const isLatin = (word: string): boolean => LATIN_WORD.test(word);
+
+/** 区切りの位置。英字の区切りは前後が空白。 */
+const separatorsIn = (text: string, separator: string): number[] =>
+  [...text.matchAll(new RegExp(separator.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"), "giu"))]
+    .map((match) => match.index)
+    .filter((index) => !isLatin(separator) || (text.charAt(index - 1) === " " && [" ", ""].includes(text.charAt(index + separator.length))));
+
+type Subject = { readonly key: string; readonly label: string; readonly lead: Span | undefined; readonly restStart: number };
+
+/** 文の頭から区切りまでの主語。読点の前は条件の句。 */
+const subjectOf = (source: string, from: number, to: number, words: TermValueWords): Subject | undefined => {
+  const clause = source.slice(from, to);
+  for (const separator of words.separators.toSorted((left, right) => right.length - left.length)) {
+    for (const index of separatorsIn(clause, separator)) {
+      const head = clause.slice(0, index);
+      const comma = [...head.matchAll(CLAUSE_COMMAS)].at(-1)?.index;
+      const label = withoutEdgeMarks(comma === undefined ? head : head.slice(comma + 1));
+      const key = termKeyOf(label, words);
+      if (key === undefined) continue;
+      return { key, label, lead: comma === undefined ? undefined : { start: from, end: from + comma }, restStart: from + index + separator.length };
+    }
+  }
+  return undefined;
+};
+
+const startsBefore = (words: TermValueWords): string[] => words.starts.filter((word) => word.position === "before").map((word) => word.pattern);
+const startsAfter = (words: TermValueWords): string[] => words.starts.filter((word) => word.position === "after").map((word) => word.pattern);
+
+/** 区切りと値のあいだ。空か、起算の句（お買い上げ日から）。句の中の値は日付だけ。 */
+const startBeforeValue = (source: string, span: Span, values: readonly FactValue[], words: TermValueWords): Span | undefined => {
+  const rest = source.slice(span.start, span.end).replace(/^[、，\s]+/u, "");
+  if (rest === "") return { start: span.end, end: span.end };
+  const phraseStart = span.end - rest.length;
+  const inside = rest.split("").some((char) => PHRASE_STOPS.has(char));
+  const marked = startsBefore(words).some((mark) => rest.endsWith(mark));
+  if (!marked || inside || rest.length > MAX_START_PHRASE) return undefined;
+  const phrase = { start: phraseStart, end: span.end };
+  return valuesIn(values, phrase).every((value) => value.kind === "date") ? phrase : undefined;
+};
+
+const insideDate = (offset: number, dates: readonly FactValue[]): boolean => dates.some((date) => date.start <= offset && offset < date.end);
+
+/** 値の後ろの起算の句（from the date of purchase）の終わり。日付の中の , は句の切れ目ではない。 */
+const startAfterValue = (source: string, at: number, values: readonly FactValue[], words: TermValueWords): Span => {
+  const lineEnd = lineEndOf(source, at);
+  const mark = startsAfter(words).find((word) => source.slice(at, at + word.length + 2).toLowerCase() === ` ${word.toLowerCase()} `);
+  if (mark === undefined) return { start: at, end: at };
+  const dates = values.filter((value) => value.kind === "date");
+  const from = at + mark.length + 2;
+  const stop = source
+    .slice(from, lineEnd)
+    .split("")
+    .findIndex((char, index) => PHRASE_STOPS.has(char) && !insideDate(from + index, dates));
+  const end = stop === -1 ? lineEnd : from + stop;
+  const trimmed = source.slice(at, end).trimEnd().length;
+  return end - at > MAX_START_PHRASE + mark.length ? { start: at, end: at } : { start: at, end: at + trimmed };
+};
+
+/**
+ * 括弧の中の終わりの日付（（2027年7月31日まで）、(until July 31, 2027)）の後ろ。日付の無い括弧（(if registered)）は条件なので、
+ * 飛ばさずに文の終わりでないとする。括弧が無ければそのまま。
+ */
+const afterEndDate = (source: string, at: number, values: readonly FactValue[]): number => {
+  const gap = source.charAt(at) === " " ? 1 : 0;
+  const open = OPEN_BRACKETS.indexOf(source.charAt(at + gap));
+  if (open === -1) return at;
+  const close = source.indexOf(CLOSE_BRACKETS[open] ?? ")", at + gap + 1);
+  if (close === -1 || close > lineEndOf(source, at)) return at;
+  const inside = valuesIn(values, { start: at + gap, end: close });
+  return inside.length > 0 && inside.every((value) => value.kind === "date") ? close + 1 : at;
+};
+
+/** 値の後ろが文の終わりか。読点の後ろは条件が続くことがある（, if you register）ので、終わりとしない。 */
+const endsSentence = (source: string, at: number, words: TermValueWords): boolean => {
+  const after = source.slice(at, lineEndOf(source, at)).trimStart();
+  const ends = words.valueEnds.filter((end) => !CLAUSE_COMMA.test(end));
+  return after === "" || after.startsWith("|") || ends.some((end) => after.startsWith(end));
+};
+
+/** 条件の句が、起算の日付と同じ日付だけを書いた例か。 */
+const isWorkedExample = (lead: Span, starts: readonly Span[], values: readonly FactValue[]): boolean => {
+  const [date, ...others] = valuesIn(values, lead);
+  if (date === undefined || others.length > 0 || date.kind !== "date") return false;
+  return starts.some((span) => valuesIn(values, span).some((value) => value.kind === "date" && sameValue(date, value)));
+};
+
+/** 主語と区切りの後ろの期間（保証期間は、お買い上げ日から24か月です）。 */
+const subjectFact = (source: string, value: FactValue, values: readonly FactValue[], words: TermValueWords): Fact | undefined => {
+  const subject = subjectOf(source, clauseStartOf(source, value.start), value.start, words);
+  if (subject === undefined) return undefined;
+  const before = startBeforeValue(source, { start: subject.restStart, end: value.start }, values, words);
+  if (before === undefined) return undefined;
+  const after = startAfterValue(source, value.end, values, words);
+  if (!endsSentence(source, afterEndDate(source, after.end, values), words)) return undefined;
+  if (subject.lead !== undefined && !isWorkedExample(subject.lead, [before, after], values)) return undefined;
+  return { label: subject.label, key: subject.key, value };
+};
+
+/** 名前のすぐ後ろの括弧の中の期間（保証期間（12か月）、warranty period (12 months)）。 */
+const bracketFact = (source: string, value: FactValue, words: TermValueWords): Fact | undefined => {
+  const open = OPEN_BRACKETS.indexOf(source.charAt(value.start - 1));
+  if (open === -1 || source.charAt(value.end) !== CLOSE_BRACKETS[open]) return undefined;
+  const from = clauseStartOf(source, value.start);
+  const label = withoutEdgeMarks(source.slice(from, value.start - 1));
+  if (CLAUSE_COMMA.test(label)) return undefined;
+  const key = termKeyOf(label, words);
+  return key === undefined ? undefined : { label, key, value };
+};
+
+const NUMBER_HEAD = /^[\d.,]+[ \t]*/u;
+
+/** 区切りの前の主語（This stay was の This stay）。文の頭が区切りで終わらなければ無い。 */
+const subjectBeforeSeparator = (clause: string, words: TermValueWords): string | undefined => {
+  const separator = words.separators.find((written) => separatorsIn(clause, written).some((index) => index + written.length === clause.length));
+  return separator === undefined ? undefined : clause.slice(0, clause.length - separator.length).trim();
+};
+
+/** 冠詞と一語だけの主語（This stay、The stay）。Previous stay、The previous stay は別のものを指すことがあるので読まない。 */
+const isBareSubject = (subject: string, words: TermValueWords): boolean => {
+  const [determiner, noun, ...rest] = folded(subject).split(" ");
+  const latin = words.determiners.map(folded).filter((word) => LATIN_WORD.test(word));
+  return noun !== undefined && rest.length === 0 && latin.includes(determiner ?? "");
+};
+
+/**
+ * 単位の語から項目の名前を書いた値（This stay was 6 days in hospital.）。名前が値の単位から始まり、その後ろで文が終わり、値の前が
+ * 冠詞と一語の主語と区切りだけのときだけ。条件の句（after 3 days in hospital）や読点の前の句の値は読まない。
+ */
+const unitNamedFact = (source: string, value: FactValue, words: TermValueWords): Fact | undefined => {
+  const unitStart = value.start + (NUMBER_HEAD.exec(source.slice(value.start, value.end))?.[0].length ?? 0);
+  const clause = source.slice(clauseStartOf(source, value.start), value.start).trimEnd();
+  const subject = CLAUSE_COMMA.test(clause) ? undefined : subjectBeforeSeparator(clause, words);
+  if (unitStart >= value.end || subject === undefined || !isBareSubject(subject, words)) return undefined;
+  const term = words.terms.find((word) => {
+    const end = unitStart + word.pattern.length;
+    return end > value.end && folded(source.slice(unitStart, end)) === folded(word.pattern) && endsSentence(source, end, words);
+  });
+  return term === undefined ? undefined : { label: source.slice(unitStart, unitStart + term.pattern.length), key: folded(term.pattern), value };
+};
+
+const DURATION_UNITS = new Set(["day", "week", "month", "year"]);
+
+/** 語彙表の項目を主語にした文の、期間の値。values は文書の中の順の値（日付を含む）。 */
+export const termValues = (source: string, values: readonly FactValue[], words: TermValueWords): Fact[] =>
+  values
+    .filter((value) => value.kind === "quantity" && DURATION_UNITS.has(value.unit))
+    .flatMap((value) => {
+      const fact = bracketFact(source, value, words) ?? subjectFact(source, value, values, words) ?? unitNamedFact(source, value, words);
+      return fact === undefined ? [] : [fact];
+    });

package/src/facts/unit-word.ts

@@ -3,6 +3,9 @@ const WORD_CHAR = /[\p{L}\p{N}]/u;
 /** 単位のすぐ後ろに、数（空白一つまで）か、ハイフンでつながる語が続く。 */
 const CONTINUED = /^(?:[ \t]?[0-9０-９]|-[\p{L}\p{N}])/u;
 
+const ENDS_LATIN = /\p{Script=Latin}$/u;
+const STARTS_LATIN = /^\p{Script=Latin}/u;
+
 const isLatinWord = (word: string): boolean => LATIN_WORD.test(word);
 
 /** 英字の語が、語として行にあるか（"x" は "box" の中では数えない）。 */
@@ -33,3 +36,13 @@ export const standsAsUnitWord = (pattern: string, needsContext: boolean, after:
   if (!needsContext || !isLatinWord(pattern)) return true;
   return !WORD_CHAR.test(after.charAt(0)) && !CONTINUED.test(after);
 };
+
+const ENDS_DIGIT = /\d$/u;
+const STARTS_WORD = /^[\p{Script=Latin}\p{N}]/u;
+
+/**
+ * 英字で終わる単位の後ろに英字が続けば、単位ではなく語の頭（"20 to" の t、"3 tons" の t、"5 miners" の min、"120 mmHg" の mm）。
+ * 数字で終わる単位（m2）は、後ろに英字か数字が続けば語の頭（"3 m23"、"5 m2x"）。
+ */
+export const runsIntoWord = (pattern: string, after: string): boolean =>
+  (ENDS_LATIN.test(pattern) && STARTS_LATIN.test(after)) || (ENDS_DIGIT.test(pattern) && STARTS_WORD.test(after));

package/src/facts/verb-quantity-facts.ts

@@ -0,0 +1,84 @@
+import type { FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+import { keyOfParts, type QualifierWords } from "./qualified-labels.ts";
+import { clauseStartOf } from "./term-values.ts";
+
+/**
+ * 動詞と「of 名詞」で項目を言う量（"You used 14.2 GB of data."）。項目の名前は名詞と動詞（data used）で、表の行の見出し
+ * "Data used" と同じ。主語が読み手か書き手（you、we）なら条件は無く、ほかの主語（The primary line）は名前の条件になる:
+ * data used (primary line) は、表の 主回線 の行の升とだけ比べる。値の後ろは「of 名詞」と、文書の期間を言う語（this month）と、
+ * 値の終わり（, や .）だけ。"used 3 GB of data on the trip" のような句が続く値は、条件が付くので読まない。
+ */
+export type VerbQuantityWords = {
+  /** 量を言う動詞。過去分詞も同じ形で、名詞の後ろに置いて項目の名前になるもの（used、consumed）。 */
+  readonly verbs: readonly string[];
+  /** 文書の宛先か書き手を指す主語（you、we）。名前に条件を付けない。 */
+  readonly selves: readonly string[];
+  /** 文書の期間そのものを言う語（this month）。値の後ろに置いても、値を変えない。 */
+  readonly periods: readonly string[];
+  readonly valueEnds: readonly string[];
+  readonly qualifiers: QualifierWords;
+};
+
+const MAX_SUBJECT_WORDS = 4;
+const SUBJECT = /^\p{L}+(?: \p{L}+)*$/u;
+const OF_NOUN = /^ of (\p{L}+)/u;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const lineEndOf = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+type Subject = { readonly written: string; readonly verb: string };
+
+/** 値の前の「主語 動詞 」。主語は字と空白だけの短い句。 */
+const subjectBefore = (source: string, value: FactValue, words: VerbQuantityWords): Subject | undefined => {
+  const head = source.slice(clauseStartOf(source, value.start), value.start);
+  const verb = words.verbs.find((word) => folded(head).endsWith(` ${folded(word)} `));
+  if (verb === undefined) return undefined;
+  const written = head.slice(0, head.length - verb.length - 2).trim();
+  const ok = SUBJECT.test(written) && written.split(" ").length <= MAX_SUBJECT_WORDS;
+  return ok ? { written, verb: folded(verb) } : undefined;
+};
+
+/** 名詞の後ろが、期間の語を除いて値の終わりか。 */
+const endsAfterNoun = (rest: string, words: VerbQuantityWords): boolean => {
+  const period = words.periods.find((word) => folded(rest).startsWith(` ${folded(word)}`));
+  const after = period === undefined ? rest : rest.slice(period.length + 1);
+  return after === "" || after.startsWith("|") || words.valueEnds.some((end) => after.startsWith(end));
+};
+
+/** 値の後ろの「of 名詞」の名詞。後ろが値の終わりでなければ undefined。 */
+const nounAfter = (source: string, value: FactValue, words: VerbQuantityWords): string | undefined => {
+  const tail = source.slice(value.end, lineEndOf(source, value.end));
+  const match = OF_NOUN.exec(tail);
+  if (match === null || match[1] === undefined) return undefined;
+  return endsAfterNoun(tail.slice(match[0].length), words) ? folded(match[1]) : undefined;
+};
+
+/** 単位の字を持つ量（14.2 GB、300 kWh）。金額と率は、動詞の後ろでも読まない。 */
+const isMeasured = (value: FactValue): boolean => value.kind === "quantity" && /\p{L}/u.test(value.unit);
+
+const keyOf = (name: string, subject: string, words: VerbQuantityWords): string | undefined => {
+  if (words.selves.some((self) => folded(self) === folded(subject))) return name;
+  return keyOfParts(name, subject, words.qualifiers);
+};
+
+const verbQuantityFact = (source: string, value: FactValue, words: VerbQuantityWords): Fact | undefined => {
+  if (!isMeasured(value)) return undefined;
+  const subject = subjectBefore(source, value, words);
+  const noun = subject === undefined ? undefined : nounAfter(source, value, words);
+  if (subject === undefined || noun === undefined) return undefined;
+  const name = `${noun} ${subject.verb}`;
+  const key = keyOf(name, subject.written, words);
+  return key === undefined ? undefined : { label: key, key, value };
+};
+
+/** 文の、動詞と「of 名詞」で項目を言う量。 */
+export const verbQuantityFacts = (source: string, values: readonly FactValue[], words: VerbQuantityWords): Fact[] =>
+  values.flatMap((value) => {
+    const fact = verbQuantityFact(source, value, words);
+    return fact === undefined ? [] : [fact];
+  });

package/src/facts/whole-counts.ts

@@ -0,0 +1,183 @@
+import type { Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "./table-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 文が全体の数として書いた数（「チケットは、合計4枚です」「for 4 tickets in total」）を、その数を数える表の列（枚数、Tickets）と比べる。
+ * 文の数は、全体の印（合計、in total）と、列の項目を数える語（枚、tickets）の両方が付いたときだけ読む。「うち2枚は」「2 of the tickets」
+ * のような一部の数は印が無いので読まない。
+ * 表の側は、合計の行がその列に数を書いていればそれ。書いていなければ、行が別々のものを数える項目（チケット: 一枚は一つの行にだけ
+ * 載る）に限って、行の数の和。手数料の行（発券手数料 3枚）は同じチケットを数え直すので足さない。人は足さない: 同じ人が参加の行と
+ * 交流会の行の両方に載る。
+ */
+export type CountWord = { readonly pattern: string; readonly group: string };
+export type MarkWord = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type CountWords = {
+  /** 数を数える列の見出し（枚数、Tickets）。group が数えるもの。 */
+  readonly columns: readonly CountWord[];
+  /** 数の後ろの、数えるものの語（枚、tickets）。group が列と同じものだけを比べる。 */
+  readonly counters: readonly CountWord[];
+  /** 行が別々のものを数える group。この group だけ、行の数を足して表の全体の数にする。 */
+  readonly separateRows: readonly string[];
+  /** 全体の印。before は数のすぐ前（合計4枚）、after は数えるものの語のすぐ後ろ（4 tickets in total）。 */
+  readonly wholeMarks: readonly MarkWord[];
+  /** 全体でない数の印。before は文のその数より前のどこか（うち、各、up to）、after は数えるものの語のすぐ後ろ（まで、目）。 */
+  readonly notWhole: readonly MarkWord[];
+  /** 同じものを数え直す行の名前の語（手数料、fee）。足さない。 */
+  readonly restating: readonly string[];
+  /** 合計の行の最初の升の語（小計は入れない）。 */
+  readonly totalLabels: readonly string[];
+  /** 表の一部の合計の行の語（小計）。この行や、合計の語で始まる別の名前の行（合計（税込））がある表は、全体の数がどれか決まらない。 */
+  readonly subtotalLabels: readonly string[];
+};
+
+export type CountSentence = Span & { readonly text: string };
+
+/** 表の全体の数。sum: 合計の行でなく、行を足した数。rows: 合計の行のほかの行の名前（S席、Stalls）。 */
+export type TableCount = { readonly group: string; readonly heading: string; readonly count: number; readonly sum: boolean; readonly rows: readonly string[] };
+
+/** written: 文が書いた数の字（4、４）。数えるものの語はその後ろ。 */
+export type WholeCountConflict = Span & { readonly heading: string; readonly written: string; readonly table: TableCount };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const DIGITS = "[0-9０-９][0-9０-９,，]*";
+const LATIN_EDGE = /^[a-z]$/iu;
+
+const numberOf = (written: string): number => Number(written.normalize("NFKC").replaceAll(",", ""));
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** 升の字がちょうど「数 + 数えるものの語」（2枚、2 tickets）のときの数。 */
+const cellCount = (text: string, counters: readonly string[]): number | undefined => {
+  const cell = folded(withoutEdgeMarks(text));
+  const counter = counters.map(folded).find((word) => new RegExp(`^${DIGITS} ?${escaped(word)}$`, "u").test(cell));
+  return counter === undefined ? undefined : numberOf(cell.slice(0, cell.length - counter.length).trim());
+};
+
+const countersOf = (group: string, words: CountWords): string[] => words.counters.filter((word) => word.group === group).map((word) => word.pattern);
+
+type Row = { readonly label: string; readonly cell: string };
+
+const isTotal = (label: string, words: CountWords): boolean => words.totalLabels.some((word) => folded(word) === label);
+const looksTotal = (label: string, words: CountWords): boolean =>
+  [...words.totalLabels, ...words.subtotalLabels].some((word) => label.startsWith(folded(word)));
+const restates = (label: string, words: CountWords): boolean => words.restating.some((word) => label.includes(folded(word)));
+const startsPartial = (label: string, words: CountWords): boolean =>
+  words.notWhole.some((word) => word.position === "before" && label.startsWith(folded(word.pattern)));
+
+/** 行を足した数。どの行も数が読めて、一部の行（うち学生）が無いときだけ。 */
+const rowSum = (rows: readonly Row[], counters: readonly string[], words: CountWords): number | undefined => {
+  const items = rows.filter((row) => !isTotal(row.label, words) && !restates(row.label, words));
+  if (items.length === 0 || items.some((row) => startsPartial(row.label, words))) return undefined;
+  const counts = items.map((row) => cellCount(row.cell, counters));
+  return counts.every((count) => count !== undefined) ? counts.reduce<number>((sum, count) => sum + (count ?? 0), 0) : undefined;
+};
+
+const columnCount = (group: string, heading: string, rows: readonly Row[], words: CountWords): TableCount | undefined => {
+  const counters = countersOf(group, words);
+  const [total, ...moreTotals] = rows.filter((row) => isTotal(row.label, words));
+  if (moreTotals.length > 0 || rows.some((row) => !isTotal(row.label, words) && looksTotal(row.label, words))) return undefined;
+  const written = total === undefined ? undefined : cellCount(total.cell, counters);
+  const labels = rows.map((row) => row.label).filter((label) => label !== "" && !isTotal(label, words));
+  if (written !== undefined) return { group, heading, count: written, sum: false, rows: labels };
+  if (total !== undefined && folded(withoutEdgeMarks(total.cell)) !== "") return undefined;
+  const sum = words.separateRows.includes(group) ? rowSum(rows, counters, words) : undefined;
+  return sum === undefined ? undefined : { group, heading, count: sum, sum: true, rows: labels };
+};
+
+const rowsAt = (rows: readonly Line[], column: number): Row[] =>
+  rows.map((row) => {
+    const cells = cellsOf(row);
+    return { label: folded(withoutEdgeMarks(cells[0]?.text ?? "")), cell: cells[column]?.text ?? "" };
+  });
+
+/** 表の、数を数える列ごとの全体の数。 */
+const tableCounts = (source: string, words: CountWords): TableCount[] =>
+  tablesOf(linesOf(source)).flatMap((table) =>
+    cellsOf(table.header).flatMap((cell, column) => {
+      const heading = withoutEdgeMarks(cell.text);
+      const group = words.columns.find((word) => folded(word.pattern) === folded(heading))?.group;
+      if (group === undefined || column === 0) return [];
+      const count = columnCount(group, heading, rowsAt(table.rows, column), words);
+      return count === undefined ? [] : [count];
+    }),
+  );
+
+type Found = Span & { readonly written: string; readonly group: string };
+
+/** 語の端がラテン文字なら、隣がラテン文字でないこと（per と person を分ける）。 */
+const bounded = (text: string, start: number, end: number): boolean => {
+  const before = text.charAt(start - 1);
+  const after = text.charAt(end);
+  return !(LATIN_EDGE.test(text.charAt(start)) && LATIN_EDGE.test(before)) && !(LATIN_EDGE.test(text.charAt(end - 1)) && LATIN_EDGE.test(after));
+};
+
+const hasWord = (text: string, word: string): boolean => {
+  const at = text.indexOf(word);
+  return at !== -1 && (bounded(text, at, at + word.length) || hasWord(text.slice(at + 1), word));
+};
+
+const notWhole = (text: string, counted: Counted, words: CountWords): boolean => {
+  const before = text.slice(0, counted.start);
+  const after = text.slice(counted.after).trimStart();
+  return words.notWhole.some((word) => {
+    const pattern = folded(word.pattern);
+    return word.position === "before" ? hasWord(before, pattern) : after.startsWith(pattern) && bounded(after, 0, pattern.length);
+  });
+};
+
+/** 印 + 数 + 語（合計4枚、a total of 4 tickets）か、数 + 語 + 印（4 tickets in total）。 */
+const wholePattern = (mark: MarkWord, counter: string): RegExp => {
+  const counted = `(?<counted>${DIGITS} ?${escaped(counter)})`;
+  const word = escaped(mark.pattern);
+  return new RegExp(mark.position === "before" ? `${word} ?${counted}` : `${counted} ${word}`, "gdu");
+};
+
+/** 数と数えるものの語の位置。after: 全体の印も含めた、読んだ所の終わり（4 tickets in total の後ろ）。 */
+type Counted = Span & { readonly after: number };
+
+const matchesOf = (text: string, mark: MarkWord, counter: CountWord): Counted[] =>
+  [...text.matchAll(wholePattern({ ...mark, pattern: folded(mark.pattern) }, folded(counter.pattern)))].flatMap((match) => {
+    const [start, end] = match.indices?.groups?.["counted"] ?? [0, 0];
+    const after = match.index + match[0].length;
+    if (!bounded(text, match.index, after) || /[0-9.]/u.test(text.charAt(start - 1))) return [];
+    return [{ start, end, after }];
+  });
+
+const foundIn = (sentence: CountSentence, words: CountWords): Found[] => {
+  const text = sentence.text.normalize("NFKC").toLowerCase();
+  if (text.length !== sentence.text.length) return [];
+  return words.counters.flatMap((counter) =>
+    words.wholeMarks.flatMap((mark) =>
+      matchesOf(text, mark, counter).flatMap((counted): Found[] => {
+        if (notWhole(text, counted, words)) return [];
+        const { start, end } = counted;
+        const written = sentence.text.slice(start, end);
+        const counterAt = end - counter.pattern.length;
+        return [{ start: sentence.start + start, end: sentence.start + end, written: written.slice(0, counterAt - start).trim(), group: counter.group }];
+      }),
+    ),
+  );
+};
+
+const unique = (found: readonly Found[]): Found[] => found.filter((one, index) => found.findIndex((other) => other.start === one.start) === index);
+
+/**
+ * 文が全体として書いた数と、表のその列の全体の数が違う所。数える列が文書に二つ以上ある項目、その表の行の名前を書いた文
+ * （S席は合計2枚）は比べない。
+ */
+export const wholeCountConflicts = (source: string, sentences: readonly CountSentence[], words: CountWords): WholeCountConflict[] => {
+  const tables = tableCounts(source, words);
+  return sentences.flatMap((sentence) => {
+    const text = folded(sentence.text);
+    return unique(foundIn(sentence, words)).flatMap((found) => {
+      const [table, ...others] = tables.filter((count) => count.group === found.group);
+      if (table === undefined || others.length > 0 || numberOf(found.written) === table.count) return [];
+      if (table.rows.some((label) => hasWord(text, label))) return [];
+      return [{ start: found.start, end: found.end, heading: table.heading, written: found.written, table }];
+    });
+  });
+};

package/src/name-char-reading.ts

@@ -0,0 +1,24 @@
+/** 解析器が読みを持たない名前の字（健汰 の 汰）から、その字の名前での読みへ。語彙表 name-char-reading が言う。 */
+export type CharReadings = ReadonlyMap<string, string>;
+
+export const NO_CHAR_READINGS: CharReadings = new Map();
+
+type ReadToken = { readonly surface: string; readonly reading?: string | undefined };
+
+const isRead = (reading: string | undefined): reading is string => reading !== undefined && reading !== "";
+
+/**
+ * 語の読み。解析器の読みがあればそれ。無ければ、語の字がどれも語彙表にあるときだけ字の読みをつなぐ。一字でも読めなければ無い
+ * （読めない字を飛ばすと、別の名前を同じ読みと言ってしまう）。
+ */
+export const tokenReadingOf = (token: ReadToken, chars: CharReadings): string | undefined => {
+  if (isRead(token.reading)) return token.reading;
+  const readings = [...token.surface].map((letter) => chars.get(letter));
+  return readings.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};
+
+/** 語を並べた名前の読み。読めない語が一つでもあれば無い。 */
+export const readingOfWords = (words: readonly ReadToken[], chars: CharReadings): string | undefined => {
+  const readings = words.map((token) => tokenReadingOf(token, chars));
+  return words.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};