chaffjs 0.33.0 → 0.35.0

package/src/detectors/vague-density.ts

@@ -0,0 +1,68 @@
+// Vague words dense for the document's length (vague-word-density). Each sentence counts the vague words it holds once:
+// a word inside a longer one ("timely" in "in a timely manner") is that longer word, and a word inside a term of art of the
+// document's genre ("reasonably" in a contract, "adequately compensate" as the test for an injunction) is not vague
+// there. The rule speaks once per sentence, about the document's density. Pure: the words come from the language's
+// lexicons vague-word and vague-word-term-of-art, the genre from the options.
+import { entriesForGenre } from "../lexicon-genres.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { Detector, Finding, Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
+import { comparableText, comparableWords, entryRanges } from "./lexicon-match.ts";
+import { rateOver } from "./lexicon.ts";
+
+const TERMS_OF_ART = "vague-word-term-of-art";
+
+type Place = { readonly start: number; readonly end: number };
+
+type Match = { readonly pattern: string; readonly place: Place };
+
+/** Token spans are places in the document and text places are in the sentence, so one sentence uses one kind for every entry. */
+const readsTokens = (sentence: Sentence, entries: Lexicon): boolean =>
+  sentence.tokens !== undefined && entries.every((entry) => (entry.tokens?.length ?? 0) > 0);
+
+/** Where an entry stands in the sentence, as character spans: its tokens, or the comparable text. */
+const placesOf = (sentence: Sentence, entry: LexiconEntry, byTokens: boolean): Place[] => {
+  const tokens = sentence.tokens;
+  if (byTokens && tokens !== undefined)
+    return entryRanges(sentence, entry).map((range) => ({ start: tokens[range.start]?.span.start ?? 0, end: tokens[range.end - 1]?.span.end ?? 0 }));
+  const word = comparableWords(entry.pattern);
+  if (word === "") return [];
+  return [...comparableText(sentence).matchAll(new RegExp(escapeRegExp(word), "gu"))].map((found) => ({ start: found.index, end: found.index + word.length }));
+};
+
+const matchesOf = (sentence: Sentence, lexicon: Lexicon, byTokens: boolean): Match[] =>
+  lexicon.flatMap((entry) => placesOf(sentence, entry, byTokens).map((place) => ({ pattern: entry.pattern, place })));
+
+const covers = (outer: Place, inner: Place): boolean => outer.start <= inner.start && inner.end <= outer.end;
+
+const isLonger = (outer: Match, inner: Match): boolean => outer.place.end - outer.place.start > inner.place.end - inner.place.start;
+
+/** The vague words of one sentence, in the order written, each once: none inside a longer vague word or a term of art. */
+export const vagueWordsIn = (sentence: Sentence, vague: Lexicon, termsOfArt: Lexicon): string[] => {
+  const byTokens = readsTokens(sentence, [...vague, ...termsOfArt]);
+  const matches = matchesOf(sentence, vague, byTokens);
+  const terms = matchesOf(sentence, termsOfArt, byTokens);
+  const kept = matches.filter(
+    (match) => !matches.some((other) => isLonger(other, match) && covers(other.place, match.place)) && !terms.some((term) => covers(term.place, match.place)),
+  );
+  return [...new Set(kept.toSorted((left, right) => left.place.start - right.place.start).map((match) => match.pattern))];
+};
+
+type SentenceHits = { readonly sentence: Sentence; readonly words: readonly string[] };
+
+export const vagueDensity: Detector = (doc, options): Finding[] => {
+  const termsOfArt = entriesForGenre(doc.lexicons[TERMS_OF_ART] ?? [], options.genre);
+  const hits: SentenceHits[] = doc.sentences
+    .map((sentence) => ({ sentence, words: vagueWordsIn(sentence, options.lexicon ?? [], termsOfArt) }))
+    .filter((hit) => hit.words.length > 0);
+  const count = hits.reduce((sum, hit) => sum + hit.words.length, 0);
+  const density = rateOver(doc, count, options.limit);
+  if (density === undefined) return [];
+  return hits.map(({ sentence, words }) => ({
+    rule: "vague-word-density",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { matched: words[0] ?? "", count, density, limit: options.limit, offset: sentence.span.start },
+  }));
+};

package/src/extension/document-view.ts

@@ -1,5 +1,6 @@
 import type * as Api from "../api.ts";
 import type { BulletList, Lexicon, Markup, Paragraph, ProseDocument, Section, Sentence, Span, Token } from "../plugin.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 
 // The document as the plugin API shows it (api.ts RuleDocument): copies of only the public fields, frozen. A copy, so
 // chaff's own shapes can change without breaking a plugin; frozen, so a plugin's rule cannot change what the next rule reads.
@@ -55,7 +56,12 @@ const sectionOf = (section: Section, copy: SentenceCopies): Api.Section => ({
 const listOf = (list: BulletList): Api.List => ({ span: spanOf(list.span), itemLengths: [...list.items] });
 
 const lexiconOf = (lexicon: Lexicon): Api.Lexicon =>
-  lexicon.map((entry) => ({ pattern: entry.pattern, ...(entry.instead_of === undefined ? {} : { instead_of: entry.instead_of }) }));
+  lexicon.map((entry) => ({
+    pattern: entry.pattern,
+    ...(entry.instead_of === undefined ? {} : { instead_of: entry.instead_of }),
+    ...(entry.rewrite === undefined ? {} : { rewrite: entry.rewrite }),
+    ...(entry.genres === undefined ? {} : { genres: [...entry.genres] }),
+  }));
 
 const markupOf = (markup: Markup): Api.Markup => ({
   markdown: markup.markdown,
@@ -68,7 +74,7 @@ const markupOf = (markup: Markup): Api.Markup => ({
 
 const EMPTY_MARKUP: Markup = { markdown: false, headings: [], images: [], links: [], ids: new Set(), texts: [] };
 
-const viewOf = (doc: ProseDocument): Api.RuleDocument => {
+const viewOf = (doc: ProseDocument, genre: string | undefined): Api.RuleDocument => {
   const copy = sentenceCopier();
   const fields = deepFreeze({
     path: doc.path,
@@ -81,7 +87,7 @@ const viewOf = (doc: ProseDocument): Api.RuleDocument => {
     lists: doc.lists.map(listOf),
     listItems: doc.listSpans.map(spanOf),
     links: doc.links.map(spanOf),
-    lexicons: Object.fromEntries(Object.entries(doc.lexicons).map(([name, lexicon]) => [name, lexiconOf(lexicon)])),
+    lexicons: Object.fromEntries(Object.entries(doc.lexicons).map(([name, lexicon]) => [name, lexiconOf(entriesForGenre(lexicon, genre))])),
   });
   // The markup is read from the Markdown tree only when a rule asks for it, as chaff's own rules do.
   const markup: { value: Api.Markup | undefined } = { value: undefined };
@@ -97,13 +103,16 @@ const viewOf = (doc: ProseDocument): Api.RuleDocument => {
 /** A word list as a detector is given it (DetectorOptions.lexicon): public fields only, frozen. */
 export const frozenLexiconOf = (lexicon: Lexicon): Api.Lexicon => deepFreeze(lexiconOf(lexicon));
 
-const views = new WeakMap<ProseDocument, Api.RuleDocument>();
+// By genre too: the run, not the document, carries the genre, so one document may be run under several.
+const views = new WeakMap<ProseDocument, Map<string | undefined, Api.RuleDocument>>();
 
-/** The document as a plugin's detector sees it. Made once per document, however many plugin rules read it. */
-export const ruleDocumentOf = (doc: ProseDocument): Api.RuleDocument => {
-  const known = views.get(doc);
+/** The document as a plugin's detector sees it in a genre, its word lists holding that genre's entries. Made once per document and genre. */
+export const ruleDocumentOf = (doc: ProseDocument, genre: string | undefined): Api.RuleDocument => {
+  const byGenre = views.get(doc) ?? new Map<string | undefined, Api.RuleDocument>();
+  views.set(doc, byGenre);
+  const known = byGenre.get(genre);
   if (known !== undefined) return known;
-  const view = viewOf(doc);
-  views.set(doc, view);
+  const view = viewOf(doc, genre);
+  byGenre.set(genre, view);
   return view;
 };

package/src/extension/entry-genres.ts

@@ -0,0 +1,15 @@
+// A word-list entry's genres as a plugin writes them: a non-empty list of the genres and groups chaff knows (legal,
+// blog/tech). Pure: the known ids come in.
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** What cannot be read in genres, printed: the whole value when it is not a non-empty list, else its unknown items. undefined when it reads. */
+export const genresProblemOf = (genres: unknown, known: ReadonlySet<string>): string | undefined => {
+  if (!Array.isArray(genres) || genres.length === 0) return printed(genres);
+  const unknown = genres.filter((genre: unknown) => typeof genre !== "string" || !known.has(genre));
+  return unknown.length === 0 ? undefined : printed(unknown);
+};
+
+/** genres when they read, as a list of ids. */
+export const readGenres = (genres: unknown, known: ReadonlySet<string>): string[] | undefined =>
+  Array.isArray(genres) && genresProblemOf(genres, known) === undefined ? genres.filter((genre: unknown) => typeof genre === "string") : undefined;

package/src/extension/module-detector.ts

@@ -1,6 +1,7 @@
 import type * as Api from "../api.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { frozenLexiconOf, ruleDocumentOf } from "./document-view.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 import { returnedFindings, type ShapeProblem } from "./returned-findings.ts";
 
 // A detector a team or a plugin wrote, run as one of chaff's. It reads the document through the plugin API, and what it
@@ -38,8 +39,12 @@ const messageOf = (error: unknown): string => {
  * What the detector returned, as findings, or how it failed. Reading the return can run the plugin's code too (a getter,
  * a Proxy), so it is checked inside the try. A Promise is a wrong return; its rejection must not end the run later.
  */
-const findingsOf = (detect: UntrustedDetector, doc: ProseDocument, options: Api.DetectorOptions): { findings: Finding[] } | { failure: RuleFailure } => {
-  const view = ruleDocumentOf(doc);
+const findingsOf = (
+  detect: UntrustedDetector,
+  view: Api.RuleDocument,
+  doc: ProseDocument,
+  options: Api.DetectorOptions,
+): { findings: Finding[] } | { failure: RuleFailure } => {
   try {
     const returned: unknown = detect(view, options);
     if (returned instanceof Promise) returned.catch(() => undefined);
@@ -54,8 +59,8 @@ const findingsOf = (detect: UntrustedDetector, doc: ProseDocument, options: Api.
 export const moduleDetector =
   (detect: UntrustedDetector, origin: string): Detector =>
   (doc, options): Finding[] => {
-    const lexicon = options.lexicon === undefined ? undefined : frozenLexiconOf(options.lexicon);
-    const outcome = findingsOf(detect, doc, Object.freeze({ lexicon }));
+    const lexicon = options.lexicon === undefined ? undefined : frozenLexiconOf(entriesForGenre(options.lexicon, options.genre));
+    const outcome = findingsOf(detect, ruleDocumentOf(doc, options.genre), doc, Object.freeze({ lexicon }));
     if ("failure" in outcome) throw new PluginRuleFailure(outcome.failure, origin);
     return outcome.findings;
   };

package/src/extension/plugin-parse.ts

@@ -8,6 +8,7 @@ import { describeValue } from "./returned-findings.ts";
 import { isPluginName } from "./plugin-name.ts";
 import { knownGenres } from "../known-genres.ts";
 import { guideLayerOf, type GuideLayer, type GuideProblem } from "../genre-guide/layer.ts";
+import { genresProblemOf, readGenres } from "./entry-genres.ts";
 
 // What a plugin package exports (api.ts PluginSpec), read into what chaff runs: its rules with ids under the plugin's
 // name, their detectors, its word lists and its house styles. A rule is read exactly like a rule in custom_rules, with
@@ -28,6 +29,7 @@ type PluginProblemKind =
   | "name-mismatch"
   | "no-detect"
   | "bad-lexicon"
+  | "bad-lexicon-genres"
   | "bad-style";
 
 /** plugin: as chaff.yaml writes it. detail: what was there instead, the name expected, the rule, list or style at fault. */
@@ -137,30 +139,46 @@ const rulesOf = (raw: unknown, context: RulesContext): Rules => {
 
 // ───────── word lists ─────────
 
-const lexiconEntryOf = (value: unknown): LexiconEntry | undefined => {
+const lexiconEntryOf = (value: unknown, known: ReadonlySet<string>): LexiconEntry | undefined => {
   if (typeof value === "string") return value.trim() === "" ? undefined : { pattern: value.trim() };
   if (!isRecord(value) || typeof value["pattern"] !== "string" || value["pattern"].trim() === "") return undefined;
   const [insteadOf, rewrite] = [value["instead_of"], value["rewrite"]];
+  const genres = readGenres(value["genres"], known);
   return {
     pattern: value["pattern"].trim(),
     ...(typeof insteadOf === "string" && insteadOf.trim() !== "" ? { instead_of: insteadOf.trim() } : {}),
     ...(typeof rewrite === "string" && rewrite.trim() !== "" ? { rewrite: rewrite.trim() } : {}),
+    ...(genres === undefined ? {} : { genres }),
   };
 };
 
-const lexiconOf = (words: unknown): Lexicon | undefined => {
-  const entries = Array.isArray(words) ? words.map(lexiconEntryOf) : [undefined];
+const lexiconOf = (words: unknown, known: ReadonlySet<string>): Lexicon | undefined => {
+  const entries = Array.isArray(words) ? words.map((word: unknown) => lexiconEntryOf(word, known)) : [undefined];
   const readable = entries.flatMap((entry) => (entry === undefined ? [] : [entry]));
   // An empty list would leave its rules running and finding nothing, which reads as a clean document.
   return readable.length === entries.length && readable.length > 0 ? readable : undefined;
 };
 
+/** An entry's genres that cannot be read, as its list, language and pattern with what is wrong. */
+const entryGenresProblem = (list: string, language: string, word: unknown, known: ReadonlySet<string>): string[] => {
+  if (!isRecord(word) || word["genres"] === undefined) return [];
+  const wrong = genresProblemOf(word["genres"], known);
+  return wrong === undefined ? [] : [`${list} (${language}) ${printed(word["pattern"])}: ${wrong}`];
+};
+
+const genresProblemsOf = (list: string, raw: unknown, known: ReadonlySet<string>): string[] =>
+  isRecord(raw)
+    ? Object.entries(raw).flatMap(([language, words]) =>
+        (Array.isArray(words) ? words : []).flatMap((word: unknown) => entryGenresProblem(list, language, word, known)),
+      )
+    : [];
+
 type ListInLanguage = { readonly language: string; readonly list: string; readonly lexicon: Lexicon };
 
 /** One word list in each language it has. undefined when any part of it cannot be read. */
-const listOf = (list: string, raw: unknown): ListInLanguage[] | undefined => {
+const listOf = (list: string, raw: unknown, known: ReadonlySet<string>): ListInLanguage[] | undefined => {
   if (!LOCAL_NAME.test(list) || !isRecord(raw)) return undefined;
-  const read = Object.entries(raw).map(([language, words]) => ({ language, lexicon: lexiconOf(words) }));
+  const read = Object.entries(raw).map(([language, words]) => ({ language, lexicon: lexiconOf(words, known) }));
   const readable = read.flatMap(({ language, lexicon }) => (lexicon === undefined ? [] : [{ language, list, lexicon }]));
   return readable.length === read.length ? readable : undefined;
 };
@@ -178,12 +196,16 @@ const byLanguage = (lists: readonly ListInLanguage[], name: string): Record<stri
 const lexiconsOf = (raw: unknown, name: string, problem: Problem): Lexicons => {
   if (raw === undefined) return { lexicons: {}, lists: new Set(), problems: [] };
   if (!isRecord(raw)) return { lexicons: {}, lists: new Set(), problems: [problem("bad-lexicon", printed(raw))] };
-  const read = Object.entries(raw).map(([list, words]) => ({ list, inLanguages: listOf(list, words) }));
+  const known = new Set(knownGenres());
+  const read = Object.entries(raw).map(([list, words]) => ({ list, words, inLanguages: listOf(list, words, known) }));
   const readable = read.flatMap((entry) => entry.inLanguages ?? []);
   return {
     lexicons: byLanguage(readable, name),
     lists: new Set(readable.map((entry) => entry.list)),
-    problems: read.filter((entry) => entry.inLanguages === undefined).map((entry) => problem("bad-lexicon", entry.list)),
+    problems: [
+      ...read.filter((entry) => entry.inLanguages === undefined).map((entry) => problem("bad-lexicon", entry.list)),
+      ...read.flatMap((entry) => genresProblemsOf(entry.list, entry.words, known).map((detail) => problem("bad-lexicon-genres", detail))),
+    ],
   };
 };
 

package/src/extension/problem-text.ts

@@ -64,6 +64,8 @@ const PLUGIN_TEXT: Texts<PluginText> = {
       "name-mismatch": (plugin, detail) => `plugins の ${plugin}: name は ${detail} にしてください（パッケージの名前から決まります）`,
       "no-detect": (plugin, detail) => `plugins の ${plugin}: ルール ${detail} に detect がありません`,
       "bad-lexicon": (plugin, detail) => `plugins の ${plugin}: 語彙表 ${detail} が読めません（名前: { ja: [語, …], en: [語, …] }）`,
+      "bad-lexicon-genres": (plugin, detail) =>
+        `plugins の ${plugin}: 語彙表 ${detail} の genres が読めません。chaff の知っているジャンルかその組の並び（[legal] や [blog/tech]）で書いてください。npx chaffjs genres で一覧が出ます`,
       "bad-style": (plugin, detail) => `plugins の ${plugin}: スタイルが読めません（${detail}）`,
     },
   },
@@ -87,6 +89,8 @@ const PLUGIN_TEXT: Texts<PluginText> = {
       "name-mismatch": (plugin, detail) => `plugins ${plugin}: its name must be ${detail}, which the package's name gives`,
       "no-detect": (plugin, detail) => `plugins ${plugin}: the rule ${detail} has no detect`,
       "bad-lexicon": (plugin, detail) => `plugins ${plugin}: cannot read the word list ${detail} (name: { ja: [word, …], en: [word, …] })`,
+      "bad-lexicon-genres": (plugin, detail) =>
+        `plugins ${plugin}: cannot read the genres of the word list entry ${detail}; write a list of genres or groups chaff knows ([legal], [blog/tech]). npx chaffjs genres lists them`,
       "bad-style": (plugin, detail) => `plugins ${plugin}: cannot read a style (${detail})`,
     },
   },

package/src/facts/age-values.ts

@@ -65,14 +65,36 @@ const endsWithMark = (source: string, value: FactValue, marks: readonly string[]
 const mayBeAge = (source: string, value: FactValue, after: readonly string[]): boolean =>
   value.kind === "quantity" && (value.unit === "" || endsWithMark(source, value, after) || after.some((mark) => folded(mark).startsWith(folded(value.unit))));
 
-/** 年齢の印まで延ばした値。印が無ければ marked は false（範囲の片方なら年齢として読む）。 */
+const TABLE_ROW = /^[ \t]*\|/u;
+const NOT_LETTER = /[^\p{L}\p{N}]+/u;
+
+const lettersOf = (text: string): string[] =>
+  folded(text)
+    .split(NOT_LETTER)
+    .filter((word) => word !== "");
+
+/** 語の並びの中に、印の語の並びがそのまま続いてあるか（満期 の 満 は印ではない）。 */
+const hasWords = (words: readonly string[], mark: readonly string[]): boolean =>
+  mark.length > 0 && words.some((_, index) => mark.every((word, offset) => words[index + offset] === word));
+
+/** 表の行の見出しの升（最初の升）に年齢の印の語があり、数がそのすぐ後ろの升にある（| Age at entry | 20 to 70 |）。 */
+const underAgeHeading = (source: string, value: FactValue, words: AgeWords): boolean => {
+  const line = source.slice(source.lastIndexOf("\n", value.start - 1) + 1, value.start);
+  if (value.unit !== "" || !TABLE_ROW.test(line)) return false;
+  const [heading, ...before] = line.trim().slice(1).split("|");
+  if (heading === undefined || before.length !== 1) return false;
+  const headingWords = lettersOf(heading);
+  return words.marks.some((mark) => hasWords(headingWords, lettersOf(mark.pattern)));
+};
+
+/** 年齢の印まで延ばした値。印が無ければ marked は false（範囲の片方なら年齢として読む）。年齢を見出しにした表の行の数は、印が無くても年齢。 */
 const markedAge = (source: string, value: FactValue, words: AgeWords): Marked => {
   const after = at(words.marks, "after");
   const inside = endsWithMark(source, value, after);
   const end = inside ? value.end : wordAfter(source, value.end, after);
   const start = wordBefore(source, value.start, at(words.marks, "before"));
   const age: FactValue = { ...value, start: start ?? value.start, end: end ?? value.end, unit: "" };
-  return { age, marked: inside || start !== undefined || end !== undefined };
+  return { age, marked: inside || start !== undefined || end !== undefined || underAgeHeading(source, value, words) };
 };
 
 /** 上限の印まで延ばした値。印があれば上の端。 */

package/src/facts/column-units.ts

@@ -0,0 +1,67 @@
+import type { Span } from "../plugin.ts";
+import { linesOf } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "./table-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 表の升の値が、列の見出しで何の値か。単価の列（単価、Unit price、時給）の値は数量を掛けて金額になる値で、同じ行の見出しの金額の列
+ * （| りんご | 1,200円 |）とは別の量。見出しが単価の列の語（語彙表 unit-price-column）ならその group、group の無い語は UNIT_PRICE。
+ * 見出しが何あたりの句（/日、per day、1日あたり）を含めば、その単位。ほかの列の升は IN_FULL（そのままの値）。表の外の値は見出しを
+ * 持たないので、どの列の値とも比べる（文の「りんごは120円です」が単価か金額かは、読まないと分からない）。
+ */
+export type HeadingUnit = { readonly pattern: string; readonly group: string };
+
+export type HeadingUnitWords = {
+  /** 単価の列の見出し。見出しの全体がこの語のとき。 */
+  readonly headings: readonly HeadingUnit[];
+  /** 何あたりの句。見出しのどこかに、語の途中でなく書いたとき。 */
+  readonly phrases: readonly HeadingUnit[];
+};
+
+/** 単位を言わない単価の列（単価、Unit price）。二つの単価の列どうしは比べ、金額とは比べない。 */
+export const UNIT_PRICE = "unit-price";
+
+/** 見出しが何あたりとも言わない列（金額、Amount、料金）。 */
+export const IN_FULL = "";
+
+export type ColumnUnit = Span & { readonly column: string };
+
+const LATIN = /[a-z0-9]/iu;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+/** 句が text のその位置で、英字の語の途中でない（per day は per days の頭、/h は /hr の頭ではない）。 */
+const isWordAt = (text: string, phrase: string, at: number): boolean => {
+  const opensWord = LATIN.test(phrase.charAt(0)) && LATIN.test(text.charAt(at - 1));
+  const closesWord = LATIN.test(phrase.charAt(phrase.length - 1)) && LATIN.test(text.charAt(at + phrase.length));
+  return !opensWord && !closesWord;
+};
+
+const occurrences = (text: string, phrase: string, from = 0): number[] => {
+  const at = phrase === "" ? -1 : text.indexOf(phrase, from);
+  return at === -1 ? [] : [at, ...occurrences(text, phrase, at + 1)];
+};
+
+const standsIn = (text: string, phrase: string): boolean => occurrences(text, phrase).some((at) => isWordAt(text, phrase, at));
+
+const longest = (phrases: readonly HeadingUnit[]): HeadingUnit | undefined =>
+  phrases.reduce<HeadingUnit | undefined>((best, phrase) => (best === undefined || phrase.pattern.length > best.pattern.length ? phrase : best), undefined);
+
+/** 見出しの言う単位。見出しが単価の列の語ならその group。でなければ見出しに書いた句の単位（二つ当たれば長い句）。どちらも無ければ IN_FULL。 */
+export const headingPerUnit = (heading: string, words: HeadingUnitWords): string => {
+  const text = folded(withoutEdgeMarks(heading));
+  if (text === "") return IN_FULL;
+  const named = words.headings.find((word) => folded(word.pattern) === text);
+  return named?.group ?? longest(words.phrases.filter((phrase) => standsIn(text, folded(phrase.pattern))))?.group ?? IN_FULL;
+};
+
+/** 文書の表すべての本体の升と、その列の見出しの単位。 */
+export const columnUnits = (source: string, words: HeadingUnitWords): ColumnUnit[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const units = cellsOf(table.header).map((cell) => headingPerUnit(cell.text, words));
+    return table.rows.flatMap((row) => cellsOf(row).map((cell, index): ColumnUnit => ({ start: cell.start, end: cell.end, column: units[index] ?? IN_FULL })));
+  });
+
+/** 値のある升の列の単位。表の外の値は undefined。 */
+export const columnUnitAt = (columns: readonly ColumnUnit[], value: Span): string | undefined =>
+  columns.find((column) => value.start >= column.start && value.end <= column.end)?.column;

package/src/facts/fact-scope.ts

@@ -118,20 +118,69 @@ const headCount = (heads: ReadonlyMap<string, readonly number[]>, from: number,
 
 type Lines = { readonly lines: readonly Line[]; readonly breakers: readonly number[]; readonly heads: ReadonlyMap<string, readonly number[]> };
 
-const scopeOf = (fact: Fact, innermost: StructureNode | undefined, at: Lines): { scope: string; record: boolean } => {
+/** 表の、見出しを繰り返した何番目の並びの升か（table-facts の columnGroup）。並びごとに別の範囲。 */
+type PlacedFact = Fact & { readonly columnGroup?: number };
+
+const scopeOf = (fact: PlacedFact, innermost: StructureNode | undefined, at: Lines): { scope: string; record: boolean } => {
   const index = lineIndexAt(at.lines, fact.value.start);
   const from = innermost === undefined ? 0 : lineIndexAt(at.lines, innermost.span.start);
   const to = innermost === undefined ? at.lines.length : lineIndexAt(at.lines, innermost.span.end - 1) + 1;
-  const scope = [innermost?.address ?? "doc", (at.breakers[index] ?? 0) - (at.breakers[from] ?? 0), parentItem(at.lines, index)].join("#");
+  const place = [innermost?.address ?? "doc", (at.breakers[index] ?? 0) - (at.breakers[from] ?? 0), parentItem(at.lines, index)];
+  const scope = [...place, ...(fact.columnGroup === undefined ? [] : [`g${fact.columnGroup}`])].join("#");
   return { scope, record: headCount(at.heads, from, to, fact.key) >= RECORD_REPEATS };
 };
 
+const MAX_PARAGRAPH_HEAD = 40;
+/** 文の終わりか続きの印。これで終わる行は小見出しではない。 */
+const SENTENCE_END = /[.!?。．！？:：;；,、，]$/u;
+const NOT_PLAIN_LINE = /^[ \t]*(?:[#>|]|```|~~~)/u;
+/** setext の見出しの下線。上の行は見出しで、節として木が分ける。 */
+const SETEXT_UNDERLINE = /^[ \t]*(?:=+|-+)[ \t]*$/u;
+
+/**
+ * 段落の頭の、短い名前だけの行（「Example」「Element 1 (standard rated portion)」「例」）。文の終わりの印も値も無く、項目や表の行でもない。
+ * 例や場合ごとに名前を付けた段落の頭で、続く値はその例の値。
+ */
+const isNameOnly = (line: string): boolean => {
+  const text = line.trim();
+  if (text === "" || text.length > MAX_PARAGRAPH_HEAD) return false;
+  return /\p{L}/u.test(text) && !SENTENCE_END.test(text) && !LIST_ITEM.test(line) && !NOT_PLAIN_LINE.test(line);
+};
+
+const isParagraphHead = (lines: readonly Line[], index: number, valueLines: ReadonlySet<number>): boolean => {
+  const startsParagraph = (lines[index - 1]?.text.trim() ?? "") === "";
+  const isSetextHeading = SETEXT_UNDERLINE.test(lines[index + 1]?.text ?? "");
+  return startsParagraph && !isSetextHeading && !valueLines.has(index) && isNameOnly(lines[index]?.text ?? "");
+};
+
+/** 小見出しの代わりの行の数に、段落の頭の名前だけの行も数える。 */
+const withParagraphHeads = (lines: readonly Line[], facts: readonly Fact[]): number[] => {
+  const valueLines = new Set(facts.map((fact) => lineIndexAt(lines, fact.value.start)));
+  return lines.reduce<number[]>(
+    (counts, line, index) => {
+      counts.push((counts[index] ?? 0) + (isBreaker(line) || isParagraphHead(lines, index, valueLines) ? 1 : 0));
+      return counts;
+    },
+    [0],
+  );
+};
+
+/** paragraphHeads: 段落の頭の名前だけの行（Example、例）でも範囲を分ける。 */
+export type ScopeReading = { readonly paragraphHeads?: boolean };
+
 /** 事実ごとに、比べてよい範囲と、文書のどの部分かを付ける。 */
-export const scopedFacts = (facts: readonly Fact[], tree: StructureNode, source: string, summaryWords: readonly string[]): ScopedFact[] => {
+export const scopedFacts = (
+  facts: readonly PlacedFact[],
+  tree: StructureNode,
+  source: string,
+  summaryWords: readonly string[],
+  reading: ScopeReading = {},
+): ScopedFact[] => {
   if (facts.length === 0) return [];
   const nodes = inDocumentOrder(tree).filter((node) => CONTAINERS.has(node.kind));
   const lines = linesOf(source);
-  const at: Lines = { lines, breakers: breakerCounts(lines), heads: headLines(lines) };
+  const breakers = reading.paragraphHeads === true ? withParagraphHeads(lines, facts) : breakerCounts(lines);
+  const at: Lines = { lines, breakers, heads: headLines(lines) };
   return facts
     .toSorted((left, right) => left.value.start - right.value.start)
     .map((fact) => {

package/src/facts/fact-values.ts

@@ -12,6 +12,8 @@ export type ValueKind = "quantity" | "date" | "name";
 /**
  * bound: upper なら key は上の端（満70歳まで、20 to 70 の 70）。lower は範囲の下の端（満20歳〜満70歳 の 20）。
  * basis: 率に書いた基準（period:year、kind:fixed）。両方に書いた同じ種類の基準が違えば、別の量として比べない。
+ * per: 何あたりの値か（1kmあたり15円 の km、per-unit.ts）。何あたりかの違う値、片方だけ何あたりの値は比べない。
+ * column: 表の升の値の、列の見出しの単位（単価の列、column-units.ts）。どちらも表の升で、列の単位が違えば比べない。
  */
 export type FactValue = Span & {
   readonly kind: ValueKind;
@@ -20,6 +22,8 @@ export type FactValue = Span & {
   readonly bound?: "upper";
   readonly lower?: string;
   readonly basis?: RateBasis;
+  readonly per?: string;
+  readonly column?: string;
 };
 
 const attr = (node: StructureNode, name: string): string => String(node.attrs[name] ?? "");
@@ -124,10 +128,16 @@ const comparableDates = (left: string, right: string): [string, string] | undefi
 const comparableBounds = (left: FactValue, right: FactValue): boolean =>
   (left.lower === undefined || right.bound === "upper") && (right.lower === undefined || left.bound === "upper");
 
+/** 表の外の値は列を持たないので、どの列の値とも比べる。二つの升は、列の見出しの単位が同じときだけ（単価と金額は別の量）。 */
+const sameColumn = (left: FactValue, right: FactValue): boolean => left.column === undefined || right.column === undefined || left.column === right.column;
+
 /** 同じ種類の値で、比べられるもの。数量は同じ単位どうし（単位の違いは別の rule が見る）。 */
 export const comparable = (left: FactValue, right: FactValue): boolean => {
   if (left.kind !== right.kind) return false;
-  if (left.kind === "quantity") return left.unit === right.unit && comparableBounds(left, right) && basesAgree(left.basis, right.basis);
+  if (left.kind === "quantity")
+    return (
+      left.unit === right.unit && left.per === right.per && sameColumn(left, right) && comparableBounds(left, right) && basesAgree(left.basis, right.basis)
+    );
   return left.kind !== "date" || comparableDates(left.key, right.key) !== undefined;
 };
 

package/src/facts/labelled-facts.ts

@@ -10,7 +10,14 @@ import { isRate, joinsNextClause, rateHead, rateTail, type RateBasis, type RateW
  * 「$300 per person」）、条件の付いた値なので読まない。読点のあとから始まる名前（「大人は、」「For adults, the fee」）も、
  * 前に条件があるので読まない。言語の知識（区切り、値の終わり、落とす冠詞）は言語パッケージの語彙表から取る。
  */
-export type AttributePhrase = { readonly pattern: string; readonly position: "before" | "after" };
+/** clause: 主語から書いた節（you can apply）。前に読点があれば、読点の前の句は条件（For the basic plan, you can apply）。 */
+export type AttributePhrase = { readonly pattern: string; readonly position: "before" | "after"; readonly clause?: boolean };
+
+type AttributeEntry = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
+
+/** 語彙表の言い回し。group が clause なら主語から書いた節。 */
+export const attributePhrasesOf = (entries: readonly AttributeEntry[]): AttributePhrase[] =>
+  entries.map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "before", clause: entry.group === "clause" }));
 
 export type FactWords = {
   /** 名前と値の区切り（：、は、is）。英字だけの区切りは、前が空白のときだけ。 */
@@ -173,6 +180,9 @@ const labelledFact = (source: string, read: FactValue, words: FactWords): Fact |
   return undefined;
 };
 
+/** 前に置いた言い回しの前に、同じ文の読点がある（For the basic plan, you can apply）。読点の前の句は条件。 */
+const afterCondition = (head: string, phrase: string): boolean => CLAUSE_COMMA.test(afterLastBreak(head.slice(0, head.length - phrase.length)));
+
 /** 属性の言い回しのすぐ前か後ろの値。名前は言い回しそのもの。 */
 const attributeFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
   const head = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS).toLowerCase();
@@ -183,7 +193,11 @@ const attributeFact = (source: string, value: FactValue, words: FactWords): Fact
   const found = words.attributes.find((phrase) =>
     phrase.position === "before" ? head.endsWith(phrase.pattern.toLowerCase()) : tail.startsWith(phrase.pattern.toLowerCase()),
   );
-  if (found === undefined || (found.position === "before" && !endsAfter(source, value, words))) return undefined;
+  if (
+    found === undefined ||
+    (found.position === "before" && (!endsAfter(source, value, words) || (found.clause === true && afterCondition(head, found.pattern))))
+  )
+    return undefined;
   return { label: found.pattern, key: keyOf(found.pattern, words), value };
 };