chaffjs 0.32.0 → 0.34.0

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

package/src/facts/per-unit.ts

@@ -0,0 +1,105 @@
+import type { FactValue } from "./fact-values.ts";
+import { columnUnitAt, columnUnits, UNIT_PRICE, type HeadingUnitWords } from "./column-units.ts";
+
+/**
+ * 値が何あたりか（1kmあたり15円、毎月5,000円、$0.45 per mile、日額5,000円）。単位が量（時間、日、月、km、mile。語彙表 rate-unit）の
+ * 値は、その量を掛けて金額になる単価なので、同じ単位あたりの値とだけ比べる。1kmあたり15円 と 表の 1,650円 は別の量。
+ * 件や回ごと（1件につき220円、for each transfer）は量ではない。手数料の表は 1件分 を印なしで書く（| 振込手数料 | 165円 |）ので、
+ * 何あたりとは読まず、これまでどおり比べる。決まった印（日額、/km、a day）は語彙表 per-unit-mark が単位まで言う。
+ * 型（*あたり、毎*、per *）は * に rate-unit の単位の語（日 は day）を入れた句だけを読む。型の position は値のどちら側に書くか。
+ */
+export type PerUnitMark = { readonly pattern: string; readonly group: string };
+
+export type PerUnitTemplate = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type PerUnitWords = {
+  /** 単位まで決まった印（日額、/km、a day）。group が単位。 */
+  readonly marks: readonly PerUnitMark[];
+  /** * が単位の語の型（*あたり、毎*、per *）。 */
+  readonly templates: readonly PerUnitTemplate[];
+  /** 量の単位の語と、それが数える単位（日 は day）。ここに無い語（件、回）は何あたりとは読まない。 */
+  readonly units: readonly PerUnitMark[];
+  /** 百分率の単位（%）。率の期間（年4.8%）は率の基準（rate-values）が見て、期間を書かない率とも比べるので、ここでは読まない。 */
+  readonly percentUnits: readonly string[];
+  /** 単価の列の見出し（単価、Unit price、時給）。その列の升は、見出しの単位あたりの値（column-units.ts）。 */
+  readonly priceHeadings: readonly { readonly pattern: string; readonly group?: string }[];
+};
+
+const PLACEHOLDER = "*";
+/** 印を探す、値の前と後ろの字数。「日額」「1日あたり」が値の前の数字の前に書かれる。 */
+const MARK_REACH = 24;
+/** 値の前の型と値のあいだに置ける字（空白、読点。畳んだ後の字）。1kmあたり、15円。 */
+const GAP_CHARS: ReadonlySet<string> = new Set([" ", "、", ","]);
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const LETTER = /\p{L}/u;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const withoutGapAtEnd = (text: string): string => (GAP_CHARS.has(text.slice(-1)) ? withoutGapAtEnd(text.slice(0, -1)) : text);
+
+/** 型の * に単位の語を入れた句と、その単位。* の無い型は単位を言わないので、句にならない。 */
+type Phrase = { readonly text: string; readonly group: string; readonly unitFirst: boolean };
+
+const phrasesOf = (template: PerUnitTemplate, units: readonly PerUnitMark[]): Phrase[] => {
+  const pattern = folded(template.pattern);
+  const at = pattern.indexOf(PLACEHOLDER);
+  if (at === -1) return [];
+  return units.map((unit) => ({ text: `${pattern.slice(0, at)}${folded(unit.pattern)}${pattern.slice(at + 1)}`, group: unit.group, unitFirst: at === 0 }));
+};
+
+/** 印がちょうど値の後ろに始まり、語の途中で切れていない（per mile は per milestone の頭ではない）。 */
+const startsAfter = (after: string, text: string): boolean => after.startsWith(text) && !LETTER_OR_DIGIT.test(after.charAt(text.length));
+
+/** 印がちょうど値の前で終わる。単位の語で始まる句は、前が字でない（1日につき の 日。利用日につき の 日 ではない）。 */
+const endsBefore = (before: string, text: string, unitFirst: boolean): boolean =>
+  before.endsWith(text) && !(unitFirst && LETTER.test(before.charAt(before.length - text.length - 1)));
+
+const longest = (groups: readonly { readonly length: number; readonly group: string }[]): string | undefined =>
+  groups.reduce<{ readonly length: number; readonly group: string } | undefined>(
+    (best, match) => (best === undefined || match.length > best.length ? match : best),
+    undefined,
+  )?.group;
+
+/** 値のすぐ後ろ（$100 a day、5,000円/日）かすぐ前（日額5,000円）の、決まった印の単位。 */
+const markOf = (before: string, after: string, marks: readonly PerUnitMark[]): string | undefined =>
+  marks.find((mark) => startsAfter(after, folded(mark.pattern)))?.group ?? marks.find((mark) => before.endsWith(folded(mark.pattern)))?.group;
+
+/** 値の前（1kmあたり15円、毎月5,000円）か後ろ（$0.45 per mile）の型の単位。当たる句が二つあれば長いほう（か月 と 月）。 */
+const templateOf = (before: string, after: string, words: PerUnitWords): string | undefined =>
+  longest(
+    words.templates.flatMap((template) =>
+      phrasesOf(template, words.units)
+        .filter((phrase) => (template.position === "before" ? endsBefore(before, phrase.text, phrase.unitFirst) : startsAfter(after, phrase.text)))
+        .map((phrase) => ({ length: phrase.text.length, group: phrase.group })),
+    ),
+  );
+
+/** 値が何の量あたりか。量あたりでなければ（件ごと、印なし）undefined。 */
+export const perUnitOf = (source: string, value: FactValue, words: PerUnitWords): string | undefined => {
+  const after = folded(source.slice(value.end, value.end + MARK_REACH)).trimStart();
+  const before = withoutGapAtEnd(folded(source.slice(Math.max(0, value.start - MARK_REACH), value.start)));
+  return markOf(before, after, words.marks) ?? templateOf(before, after, words);
+};
+
+/** 列の見出しを読む語: 単価の列の語と、見出しに書く何あたりの句（決まった印と、型に単位の語を入れた句）。 */
+const headingWordsOf = (words: PerUnitWords): HeadingUnitWords => ({
+  headings: words.priceHeadings.map((heading) => ({ pattern: heading.pattern, group: heading.group ?? UNIT_PRICE })),
+  phrases: [...words.marks, ...words.templates.flatMap((template) => phrasesOf(template, words.units).map(({ text, group }) => ({ pattern: text, group })))],
+});
+
+/** 値の書き方と表の列から読む、何あたりか（per）と、表の升ならその列の見出しの単位（column）。 */
+const unitsOf = (source: string, value: FactValue, words: PerUnitWords, column: string | undefined): Pick<FactValue, "per" | "column"> => {
+  const percent = words.percentUnits.some((unit) => folded(unit) === folded(value.unit));
+  if (value.kind !== "quantity" || percent) return {};
+  const per = perUnitOf(source, value, words);
+  return { ...(per === undefined ? {} : { per }), ...(column === undefined ? {} : { column }) };
+};
+
+/** 数量の値に、何あたりか（1kmあたり15円 の km）と、表の升ならその列の見出しの単位（単価の列）を付ける。 */
+export const withPerUnits = <T extends FactValue>(source: string, values: readonly T[], words: PerUnitWords): T[] => {
+  const columns = columnUnits(source, headingWordsOf(words));
+  return values.map((value) => {
+    const units = unitsOf(source, value, words, columnUnitAt(columns, value));
+    return units.per === undefined && units.column === undefined ? value : { ...value, ...units };
+  });
+};

package/src/facts/row-sentence-amounts.ts

@@ -5,18 +5,15 @@ import { withoutEdgeMarks } from "./trim-marks.ts";
  * 表の行の金額と、その行の見出しを主語に書いた文の金額（| 治療・救援費用 | 3,000万円 | と「治療・救援費用は、5,000万円を限度に」）。
  * 文は値の前後に言い回し（入院1日につき、を限度に、is paid at）を書くので、名前付きの値（labelled-facts）としては読めない。
  * 主語が行の見出しとちょうど同じで、同じ範囲にあり、行と文のどちらにも同じ通貨の金額がちょうど一つのときだけ比べる。
- * 二つ以上あれば、どれがどれに当たるか（日額と上限）は読まないと分からないので比べない。期間あたりの印（日額、a day）が両方に
- * あって期間が違えば（日額と月額）、別の値なので比べない。
+ * 二つ以上あれば、どれがどれに当たるか（日額と上限）は読まないと分からないので比べない。何あたりの金額（日額、1kmあたり）は、
+ * 同じ何あたりの金額とだけ比べる（fact-values の comparable）。日額と月額、1kmあたりの単価とそれを掛けた金額は別の値。
  */
-/** period: 金額の前後に書いた期間あたりの印の期間（日額 の day）。 */
-export type Amount = FactValue & { readonly period?: string };
+export type Amount = FactValue;
 
 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[];
@@ -28,8 +25,6 @@ export type SubjectWords = {
 
 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;
@@ -38,20 +33,6 @@ 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);
@@ -87,13 +68,10 @@ const onlyPair = (row: AmountRow, sentence: SubjectSentence, value: Amount): Amo
   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 }];
+    return other === undefined || sameValue(other, value) ? [] : [{ label: row.label, value, other }];
   });
 
 const rowsByScope = (rows: readonly AmountRow[]): ReadonlyMap<string, AmountRow[]> =>

package/src/facts/table-facts.ts

@@ -1,6 +1,7 @@
 import type { Span } from "../plugin.ts";
 import { linesOf, type Line } from "../structure/lines.ts";
 import { TABLE_RULE } from "../structure/runs.ts";
+import { fencedLineIndexes } from "../structure/fenced-lines.ts";
 import { CELL_SEPARATOR } from "../structure/bare-numbers.ts";
 import type { FactValue } from "./fact-values.ts";
 import type { Fact } from "./labelled-facts.ts";
@@ -29,15 +30,17 @@ export const cellsOf = (line: Line): Cell[] => {
 
 const plain = withoutEdgeMarks;
 
-/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。 */
-export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
-  lines.flatMap((line, index) => {
+/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。コードブロックの中の表は例なので読まない。 */
+export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] => {
+  const fenced = fencedLineIndexes(lines.map((line) => line.text));
+  return lines.flatMap((line, index) => {
     const header = lines[index - 1];
-    if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
+    if (fenced.has(index) || !TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
     const after = lines.slice(index + 1);
     const end = after.findIndex((row) => !row.text.includes("|"));
     return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
   });
+};
 
 const inside = (cell: Span, value: FactValue): boolean => value.start >= cell.start && value.end <= cell.end;