chaffjs 0.30.0 → 0.32.0

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/row-sentence-amounts.ts

@@ -0,0 +1,113 @@
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 表の行の金額と、その行の見出しを主語に書いた文の金額（| 治療・救援費用 | 3,000万円 | と「治療・救援費用は、5,000万円を限度に」）。
+ * 文は値の前後に言い回し（入院1日につき、を限度に、is paid at）を書くので、名前付きの値（labelled-facts）としては読めない。
+ * 主語が行の見出しとちょうど同じで、同じ範囲にあり、行と文のどちらにも同じ通貨の金額がちょうど一つのときだけ比べる。
+ * 二つ以上あれば、どれがどれに当たるか（日額と上限）は読まないと分からないので比べない。期間あたりの印（日額、a day）が両方に
+ * あって期間が違えば（日額と月額）、別の値なので比べない。
+ */
+/** period: 金額の前後に書いた期間あたりの印の期間（日額 の day）。 */
+export type Amount = FactValue & { readonly period?: string };
+
+export type AmountRow = { readonly label: string; readonly scope: string; readonly amounts: readonly Amount[] };
+
+export type SubjectSentence = { readonly text: string; readonly scope: string; readonly amounts: readonly Amount[] };
+
+export type PeriodMark = { readonly pattern: string; readonly group: string };
+
+export type SubjectWords = {
+  /** 主語と述べる部分の区切り（は、は、、is、are）。英字だけの区切りは、前が空白で後ろが語の切れ目のときだけ。 */
+  readonly separators: readonly string[];
+  /** 主語の頭から落とす語（the）。 */
+  readonly determiners: readonly string[];
+  /** 文の金額に条件を付ける語（場合、if）。英字の語は語の切れ目にあるときだけ。 */
+  readonly conditions: readonly string[];
+};
+
+export type RowSentenceConflict = { readonly label: string; readonly value: FactValue; readonly other: FactValue };
+
+const SPACE = /^[ \t]?/u;
+const MARK_REACH = 16;
+const STRONG_MARK = /\*\*|__/gu;
+const LATIN_WORD = /^[a-z ]+$/iu;
+const LATIN_LETTER = /[a-z]/iu;
+const BLOCK_MARK = /^[ \t]*(?:#{1,6}[ \t]+|>[ \t]?)?/u;
+const ITEM_MARK = /^(?:[-*+]|\d{1,3}[.)])[ \t]+/u;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const markAt = (text: string, marks: readonly PeriodMark[]): string | undefined => {
+  const lowered = folded(text);
+  return marks.find((mark) => lowered.startsWith(folded(mark.pattern)))?.group;
+};
+
+const markBefore = (text: string, marks: readonly PeriodMark[]): string | undefined => {
+  const lowered = folded(text).trimEnd();
+  return marks.find((mark) => lowered.endsWith(folded(mark.pattern)))?.group;
+};
+
+/** 金額のすぐ前（日額5,000円）かすぐ後ろ（$100 a day、5,000円/日）の期間あたりの印の期間。 */
+export const periodOf = (source: string, value: FactValue, marks: readonly PeriodMark[]): string | undefined =>
+  markAt(source.slice(value.end).replace(SPACE, ""), marks) ?? markBefore(source.slice(Math.max(0, value.start - MARK_REACH), value.start), marks);
+
+const withoutDeterminer = (text: string, determiners: readonly string[]): string => {
+  const word = determiners.map(folded).find((determiner) => LATIN_WORD.test(determiner) && text.startsWith(`${determiner} `));
+  return word === undefined ? text : text.slice(word.length + 1);
+};
+
+/** 主語のすぐ後ろが区切りか。英字の区切りは、空白一つを挟み、後ろが英字でないときだけ（「is」は「island」の頭ではない）。 */
+const startsWithSeparator = (rest: string, separators: readonly string[]): boolean =>
+  separators.map(folded).some((separator) => {
+    if (!LATIN_WORD.test(separator)) return rest.startsWith(separator);
+    return rest.startsWith(` ${separator}`) && !LATIN_LETTER.test(rest.charAt(separator.length + 1));
+  });
+
+/** 文の主語が、ちょうどその名前か（「入院給付金は、」"Hospital cash is"）。名前に続く語があれば（入院給付金の、Hospital cash cover）違う。 */
+export const namesSubject = (text: string, label: string, words: SubjectWords): boolean => {
+  const key = withoutDeterminer(folded(label), words.determiners);
+  const head = withoutDeterminer(folded(withoutEdgeMarks(text.replace(BLOCK_MARK, "").replace(ITEM_MARK, "").replace(STRONG_MARK, ""))), words.determiners);
+  return head.startsWith(key) && startsWithSeparator(head.slice(key.length), words.separators);
+};
+
+/** 文に条件の語があるか（「集中治療室に入院した場合は」"if you are in intensive care"）。 */
+export const hasCondition = (text: string, conditions: readonly string[]): boolean => {
+  const lowered = folded(text);
+  return conditions.map(folded).some((word) => {
+    if (!LATIN_WORD.test(word)) return lowered.includes(word);
+    return new RegExp(`(?<![a-z])${word}(?![a-z])`, "u").test(lowered);
+  });
+};
+
+/** 文の金額と比べられる、行の唯一の金額。文にも、比べられる金額がほかに無いときだけ。 */
+const onlyPair = (row: AmountRow, sentence: SubjectSentence, value: Amount): Amount | undefined => {
+  const inRow = row.amounts.filter((amount) => comparable(amount, value));
+  const inSentence = sentence.amounts.filter((amount) => comparable(amount, value));
+  return inRow.length === 1 && inSentence.length === 1 ? inRow[0] : undefined;
+};
+
+/** 期間の違う金額（日額と月額）は別の値。片方にしか印が無ければ比べる（1日につき は語彙表に無い書き方）。 */
+const samePeriod = (left: Amount, right: Amount): boolean => left.period === undefined || right.period === undefined || left.period === right.period;
+
+const conflictsWith = (row: AmountRow, sentence: SubjectSentence): RowSentenceConflict[] =>
+  sentence.amounts.flatMap((value) => {
+    const other = onlyPair(row, sentence, value);
+    return other === undefined || sameValue(other, value) || !samePeriod(other, value) ? [] : [{ label: row.label, value, other }];
+  });
+
+const rowsByScope = (rows: readonly AmountRow[]): ReadonlyMap<string, AmountRow[]> =>
+  rows.reduce((byScope, row) => byScope.set(row.scope, [...(byScope.get(row.scope) ?? []), row]), new Map<string, AmountRow[]>());
+
+/**
+ * 同じ範囲で、主語がその行の見出しの文。同じ見出しの行が範囲に二つあれば、どちらの値か分からないので比べない。
+ * 条件の語のある文は、その場合の値なので比べない。
+ */
+export const rowSentenceConflicts = (rows: readonly AmountRow[], sentences: readonly SubjectSentence[], words: SubjectWords): RowSentenceConflict[] => {
+  const byScope = rowsByScope(rows);
+  return sentences.flatMap((sentence) => {
+    const named = (byScope.get(sentence.scope) ?? []).filter((row) => namesSubject(sentence.text, row.label, words));
+    const [row] = named;
+    return row === undefined || named.length > 1 || hasCondition(sentence.text, words.conditions) ? [] : conflictsWith(row, sentence);
+  });
+};

package/src/facts/superscript-power.ts

@@ -0,0 +1,5 @@
+/** A digit with a superscript digit right after it (10³, １０²): a power, which NFKC would turn into a longer number (103). */
+const DIGIT_THEN_SUPERSCRIPT = /\p{Nd}[⁰¹²³⁴-⁹]/u;
+
+/** Whether the text, before NFKC, writes a power of a number. A unit's superscript (m³, km²) follows a letter, not a digit. */
+export const hasSuperscriptPower = (text: string): boolean => DIGIT_THEN_SUPERSCRIPT.test(text);

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