chaffjs 0.31.0 → 0.33.0

package/src/facts/duration-scale.ts

@@ -0,0 +1,22 @@
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+
+/**
+ * 期間を、比べられる単位に揃えた大きさ。年は月に直す（1年 と 12か月 は同じ長さ、2年 と 12か月 は違う長さ）。
+ * 月と日、週と日は直さない: 1か月 は 28〜31日で、30日 と同じとは言えない。週と日はそのまま別の単位で、比べない。
+ */
+export type ScaledDuration = { readonly key: string; readonly unit: DurationUnit };
+
+const MONTHS_PER_YEAR = 12;
+/** 0.1年 × 12 の浮動小数の端（1.2000000000000002）を落とす桁。 */
+const KEY_DIGITS = 1e6;
+
+const scaledKey = (key: string, factor: number): string | undefined => {
+  const amount = key.trim() === "" ? Number.NaN : Number(key);
+  return Number.isFinite(amount) ? String(Math.round(amount * factor * KEY_DIGITS) / KEY_DIGITS) : undefined;
+};
+
+export const scaledDuration = (key: string, unit: DurationUnit): ScaledDuration => {
+  if (unit !== "year") return { key, unit };
+  const months = scaledKey(key, MONTHS_PER_YEAR);
+  return months === undefined ? { key, unit } : { key: months, unit: "month" };
+};

package/src/facts/duration-values.ts

@@ -0,0 +1,44 @@
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import type { FactValue } from "./fact-values.ts";
+import { scaledDuration } from "./duration-scale.ts";
+
+/**
+ * 期間の値（3 months、3ヶ月間）。木の数量は、英語では数だけ（3 の後ろの months は単位として持つ）、日本語では か月 までで 間 を含まない。
+ * 値を期間の単位の語の終わりまで延ばし、単位を期間の大きさ（month）に揃える（3ヶ月 と 6か月、1 month と 6 months を比べる）。
+ * 年は月に直して比べる（1年 と 12か月）。月と日のように長さの決まらない組は、別の単位のまま。後ろに語が続く期間（3 months ago、30 years old）は、名前付きの値の
+ * 終わり（fact-value-end）で落ちる。
+ */
+export type DurationWord = { readonly pattern: string; readonly unit: DurationUnit };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const UNIT_GAPS = new Set([" ", "\t"]);
+
+/** 書いた単位の始まり。数のすぐ後ろか、空白一つの後ろ。木の値が単位まで含んでいれば、その単位の頭。 */
+const unitStartOf = (source: string, value: FactValue): number | undefined => {
+  const written = folded(value.unit);
+  if (written === "") return undefined;
+  if (folded(source.slice(value.end - value.unit.length, value.end)) === written) return value.end - value.unit.length;
+  const gap = UNIT_GAPS.has(source.charAt(value.end)) ? 1 : 0;
+  return folded(source.slice(value.end + gap, value.end + gap + value.unit.length)) === written ? value.end + gap : undefined;
+};
+
+const LATIN_LETTER = /[a-z]/iu;
+
+/** 単位の頭から書いた、一番長い期間の語（ヶ月 より ヶ月間）。英字の語は語の途中で切らない。 */
+const longestAt = (source: string, at: number, words: readonly DurationWord[]): DurationWord | undefined =>
+  words
+    .filter((word) => folded(source.slice(at, at + word.pattern.length)) === folded(word.pattern))
+    .filter((word) => !(LATIN_LETTER.test(word.pattern.slice(-1)) && LATIN_LETTER.test(source.charAt(at + word.pattern.length))))
+    .reduce<DurationWord | undefined>((longest, word) => (longest === undefined || word.pattern.length > longest.pattern.length ? word : longest), undefined);
+
+const durationOf = (source: string, value: FactValue, words: readonly DurationWord[]): FactValue[] => {
+  if (value.kind !== "quantity" || !words.some((word) => folded(word.pattern) === folded(value.unit))) return [];
+  const at = unitStartOf(source, value);
+  const word = at === undefined ? undefined : longestAt(source, at, words);
+  return at === undefined || word === undefined ? [] : [{ ...value, end: at + word.pattern.length, ...scaledDuration(value.key, word.unit) }];
+};
+
+/** 期間の単位の付いた数量だけを、単位の語まで含む期間の値にして返す。 */
+export const durationValues = (source: string, values: readonly FactValue[], words: readonly DurationWord[]): FactValue[] =>
+  values.flatMap((value) => durationOf(source, value, words));

package/src/facts/fact-values.ts

@@ -1,6 +1,7 @@
 import type { Span, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { overlapsAny, spanIndex, type SpanIndex } from "../compare/spans.ts";
+import { basesAgree, type RateBasis } from "./rate-values.ts";
 
 /**
  * 値として読むもの。木の数量と日付（`chaff compare` と同じ読み）と、品詞の読める言語では固有名詞。
@@ -8,7 +9,18 @@ import { overlapsAny, spanIndex, type SpanIndex } from "../compare/spans.ts";
  */
 export type ValueKind = "quantity" | "date" | "name";
 
-export type FactValue = Span & { readonly kind: ValueKind; readonly key: string; readonly unit: string };
+/**
+ * bound: upper なら key は上の端（満70歳まで、20 to 70 の 70）。lower は範囲の下の端（満20歳〜満70歳 の 20）。
+ * basis: 率に書いた基準（period:year、kind:fixed）。両方に書いた同じ種類の基準が違えば、別の量として比べない。
+ */
+export type FactValue = Span & {
+  readonly kind: ValueKind;
+  readonly key: string;
+  readonly unit: string;
+  readonly bound?: "upper";
+  readonly lower?: string;
+  readonly basis?: RateBasis;
+};
 
 const attr = (node: StructureNode, name: string): string => String(node.attrs[name] ?? "");
 
@@ -40,14 +52,27 @@ const nodeValue = (node: StructureNode, source: string): FactValue[] => {
 
 /**
  * 単位を書かない数（「Seats: 40」）。前後が字や数や時刻の : でないもの。1.2.3 のような版の番号は数にしない。
- * 単位の無い数は、単位の無い数とだけ比べる。
+ * 単位の無い数は、単位の無い数とだけ比べる。後ろのコンマは、空白と語が続くとき（2, as declared）だけ数の終わり。数が続けば
+ * 並べた数（2, 3 or 4）、一語の後ろに数が続けば別の値（3, or 4）で、空白が無ければ桁の区切りの書き損じかもしれない。
  */
-const BARE_NUMBER = /(?<![\p{L}\p{N}.,:/-])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?(?![\p{L}\p{N}%:/,，-]|[.．][0-9０-９])/gu;
+const BARE_NUMBER = /(?<![\p{L}\p{N}.,:/-])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?(?![\p{L}\p{N}%:/-]|[.．][0-9０-９])/gu;
+const COMMA = /^[,，]$/u;
+const CLAUSE_AFTER_COMMA = /[,，]\s+\p{L}/uy;
+const VALUE_AFTER_COMMA_WORD = /[,，]\s+\p{L}+\s+[0-9０-９]/uy;
+
+const matchesAt = (pattern: RegExp, source: string, offset: number): boolean => {
+  pattern.lastIndex = offset;
+  return pattern.test(source);
+};
+
+/** 数の後ろのコンマが、文の続き（, as declared）の頭か。コンマが無ければ終わり。 */
+const endsBeforeComma = (source: string, end: number): boolean =>
+  !COMMA.test(source.charAt(end)) || (matchesAt(CLAUSE_AFTER_COMMA, source, end) && !matchesAt(VALUE_AFTER_COMMA_WORD, source, end));
 
 const bareValues = (source: string, taken: SpanIndex): FactValue[] =>
   [...source.matchAll(BARE_NUMBER)].flatMap((match): FactValue[] => {
     const span = { start: match.index, end: match.index + match[0].length };
-    if (overlapsAny(taken, span)) return [];
+    if (!endsBeforeComma(source, span.end) || overlapsAny(taken, span)) return [];
     const key = String(Number(match[0].normalize("NFKC").replace(/,/gu, "")));
     return [{ ...span, kind: "quantity", key, unit: "" }];
   });
@@ -95,16 +120,20 @@ const comparableDates = (left: string, right: string): [string, string] | undefi
   return pair === undefined ? undefined : [pair[1], pair[0]];
 };
 
+/** 範囲は、上の端を言う値（上限か範囲）とだけ比べる。範囲の中のどれかの数（一人の年齢）とは比べない。 */
+const comparableBounds = (left: FactValue, right: FactValue): boolean =>
+  (left.lower === undefined || right.bound === "upper") && (right.lower === undefined || left.bound === "upper");
+
 /** 同じ種類の値で、比べられるもの。数量は同じ単位どうし（単位の違いは別の 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;
+  if (left.kind === "quantity") return left.unit === right.unit && comparableBounds(left, right) && basesAgree(left.basis, right.basis);
   return left.kind !== "date" || comparableDates(left.key, right.key) !== undefined;
 };
 
-/** 比べられる二つの値が同じか。月日だけの日付は、年まで書いた日付の月日と同じなら同じ。 */
+/** 比べられる二つの値が同じか。範囲どうしは下の端も比べる。月日だけの日付は、年まで書いた日付の月日と同じなら同じ。 */
 export const sameValue = (left: FactValue, right: FactValue): boolean => {
-  if (left.kind !== "date") return left.key === right.key;
+  if (left.kind !== "date") return left.key === right.key && (left.lower === undefined || right.lower === undefined || left.lower === right.lower);
   const pair = comparableDates(left.key, right.key);
   return pair !== undefined && pair[0] === pair[1];
 };

package/src/facts/labelled-facts.ts

@@ -1,5 +1,7 @@
 import type { FactValue } from "./fact-values.ts";
 import { EDGE_MARKS, trimEndOf, withoutEdgeMarks } from "./trim-marks.ts";
+import { qualifiedLabelOf, type QualifierWords } from "./qualified-labels.ts";
+import { isRate, joinsNextClause, rateHead, rateTail, type RateBasis, type RateWords } from "./rate-values.ts";
 
 /**
  * 名前の付いた値（「締切：10月5日」「参加費は3,000円です」"Fee: $300" "The deadline is May 3."）と、
@@ -22,12 +24,20 @@ export type FactWords = {
   /** 名前の前に置かれる決定の前置き（協議の結果、, it was decided that）。読点を含んでも条件ではないので、外してから名前を読む。 */
   readonly leads: readonly string[];
   readonly attributes: readonly AttributePhrase[];
+  /** 率のまわりの、値を変えない語（年、per year、（固定金利））。 */
+  readonly rates?: RateWords;
   /** 区切りと値のあいだに置ける目安の語（約、about）。あれば値を目安として読む。無ければ、区切りのすぐ後ろの値だけ。 */
   readonly valueLeads?: readonly string[];
+  /** 名前に条件を付ける型（（*）、*の、for *）。条件の付いた名前は、名前と条件をそれぞれ一つの名前の長さで測る。 */
+  readonly qualifiers?: QualifierWords;
+  /** 計器の読みを言う動詞（read, shows）、計器の名前（odometer, meter）、読みのあとに置ける時の節の頭（when）。 */
+  readonly readings?: ReadingWords;
 };
 
-/** approximate: 値の前に目安の語（約、about）があった。 */
-export type Fact = { readonly label: string; readonly key: string; readonly value: FactValue; readonly approximate?: boolean };
+export type ReadingWords = { readonly verbs: readonly string[]; readonly gauges: readonly string[]; readonly clauses: readonly string[] };
+
+/** approximate: 値の前に目安の語（約、about）があった。table: 表の升の値。 */
+export type Fact = { readonly label: string; readonly key: string; readonly value: FactValue; readonly approximate?: boolean; readonly table?: boolean };
 
 const MAX_LABEL_LENGTH = 24;
 const MAX_LABEL_WORDS = 5;
@@ -106,17 +116,23 @@ const containsSeparator = (label: string, words: FactWords): boolean =>
     LATIN_WORD.test(separator) ? wordsOf(label.toLowerCase()).includes(separator.toLowerCase()) : label.includes(separator),
   );
 
+const isShort = (text: string): boolean => text.length <= MAX_LABEL_LENGTH && wordsOf(text).length <= MAX_LABEL_WORDS;
+
+/** 名前の長さ。条件の付いた名前（waiting period for cancellation cover）は、名前と条件がそれぞれ短いこと。 */
+const isShortLabel = (label: string, key: string, words: FactWords): boolean => {
+  const qualified = words.qualifiers === undefined ? undefined : qualifiedLabelOf(key, words.qualifiers);
+  return qualified === undefined ? isShort(label) : isShort(qualified.head) && isShort(qualified.qualifier);
+};
+
 /** 名前として使える書き方か。短く、字を含み、区切りを含まず、指すだけの語（それ、it）でない。 */
 const isLabel = (label: string, key: string, words: FactWords): boolean =>
   label.length > 0 &&
-  label.length <= MAX_LABEL_LENGTH &&
-  wordsOf(label).length <= MAX_LABEL_WORDS &&
+  isShortLabel(label, key, words) &&
   LETTER.test(key) &&
   !CODE_MARK.test(label) &&
   !containsSeparator(label, words) &&
   !words.vague.some((word) => word.toLowerCase() === key);
 
-/** 値の後ろが文の切れ目か。行の終わり、表の升の終わり、語彙表の終わりの語。 */
 /** 値の後ろが文の切れ目か。行の終わり、表の升の終わり、語彙表の終わりの語。半角の数のまわりに空白を置く書き方（「14 cm です」）もある。 */
 const endsAfter = (source: string, value: FactValue, words: FactWords): boolean => {
   const after = source.slice(value.end, lineEndOf(source, value.end)).replace(MARKS_AFTER_VALUE, "").trimStart();
@@ -124,8 +140,25 @@ const endsAfter = (source: string, value: FactValue, words: FactWords): boolean
   return words.valueEnds.some((end) => after.startsWith(end));
 };
 
-const labelledFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
-  const written = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS);
+/** 値の終わりまで読めた値。率は、後ろの値を変えない語を越えた所で終わってもよく、そこに書いた基準を持つ。 */
+const endedValue = (source: string, value: FactValue, words: FactWords): FactValue | undefined => {
+  if (words.rates === undefined || !isRate(value, words.rates)) return endsAfter(source, value, words) ? value : undefined;
+  const tail = rateTail(source, value, words.rates);
+  const ended = endsAfter(source, { ...value, end: tail.end }, words) || joinsNextClause(source, tail.end, words.rates);
+  return ended ? withBasis(value, tail.basis) : undefined;
+};
+
+const withBasis = (value: FactValue, basis: RateBasis): FactValue => (basis.length === 0 ? value : { ...value, basis: [...(value.basis ?? []), ...basis] });
+
+/** 率の前の期間の語（年3.6% の 年）は名前の側に入れない。値の基準になる。 */
+const headOfRate = (written: string, value: FactValue, words: FactWords): { readonly head: string; readonly value: FactValue } => {
+  if (words.rates === undefined || !isRate(value, words.rates)) return { head: written, value };
+  const { head, basis } = rateHead(written, words.rates);
+  return { head, value: withBasis(value, basis) };
+};
+
+const labelledFact = (source: string, read: FactValue, words: FactWords): Fact | undefined => {
+  const { head: written, value } = headOfRate(trimEndOf(source.slice(lineStartOf(source, read.start), read.start), EDGE_MARKS), read, words);
   const head = withoutValueLead(written, words.valueLeads ?? []);
   const approximate = head.length < written.length ? { approximate: true } : {};
   for (const separator of words.separators) {
@@ -154,12 +187,36 @@ const attributeFact = (source: string, value: FactValue, words: FactWords): Fact
   return { label: found.pattern, key: keyOf(found.pattern, words), value };
 };
 
+/** 単位の語彙表の量か（"45,210 km"）。金額、率、ただの数は、読む動詞のあとでも読まない（"He read 3 chapters"）。 */
+const isMeasured = (value: FactValue): boolean => "dimension" in value;
+
+/** 値の後ろが、空白と時の節の頭の語と空白か（"45,210 km when the car came in"）。 */
+const startsClause = (source: string, end: number, clauses: readonly string[]): boolean => {
+  const after = source.slice(end, lineEndOf(source, end)).toLowerCase();
+  return /^\s/u.test(after) && clauses.some((clause) => after.trimStart().startsWith(`${clause.toLowerCase()} `));
+};
+
+/** 名前の最後の語が計器か（odometer、fuel gauge）。"The chart showed 5 kg" の chart は計器ではない。 */
+const namesGauge = (key: string, gauges: readonly string[]): boolean => {
+  const last = wordsOf(key).at(-1);
+  return last !== undefined && gauges.some((gauge) => gauge.toLowerCase() === last);
+};
+
+/** 計器が示した量（"The odometer read 45,210 km."）。読む動詞を区切りにし、値の後ろの時の節も値の終わりにする。 */
+const readingFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
+  const readings = words.readings;
+  if (readings === undefined || !isMeasured(value)) return undefined;
+  if (!endsAfter(source, value, words) && !startsClause(source, value.end, readings.clauses)) return undefined;
+  const fact = labelledFact(source, value, { ...words, separators: readings.verbs });
+  return fact !== undefined && namesGauge(fact.key, readings.gauges) ? fact : undefined;
+};
+
 /** 文に書いた名前付きの値。値ごとに、属性の言い回しか、区切りの前の名前を探す。 */
 export const labelledFacts = (source: string, values: readonly FactValue[], words: FactWords): Fact[] =>
   values.flatMap((value) => {
     const attribute = attributeFact(source, value, words);
     if (attribute !== undefined) return [attribute];
-    if (!endsAfter(source, value, words)) return [];
-    const fact = labelledFact(source, value, words);
+    const ended = endedValue(source, value, words);
+    const fact = (ended === undefined ? undefined : labelledFact(source, ended, words)) ?? readingFact(source, value, words);
     return fact === undefined ? [] : [fact];
   });

package/src/facts/measure-units.ts

@@ -1,25 +1,43 @@
-import type { ProseDocument } from "../plugin.ts";
+import type { LexiconEntry, ProseDocument } from "../plugin.ts";
 import type { MeasureUnit } from "./measures.ts";
 
-/** 量の種類ごとの語彙表。weight が基準の単位への倍率で、同じ単位を二度書けば倍率が二つ（GB の 10^9 と 2^30）。 */
-const MEASURE_DIMENSIONS = ["unit-length", "unit-mass", "unit-time", "unit-volume", "unit-data", "unit-temperature", "unit-pressure", "unit-area"] as const;
+/**
+ * 量の種類ごとの語彙表。weight が基準の単位への倍率で、同じ単位を二度書けば倍率が二つ（GB の 10^9 と 2^30）。
+ * group のある語は、語彙表の中の別の種類（mg/dL と mmol/L は換算が物質で違うので、組をまたいで比べない）。
+ */
+const MEASURE_DIMENSIONS = [
+  "unit-length",
+  "unit-mass",
+  "unit-time",
+  "unit-volume",
+  "unit-data",
+  "unit-temperature",
+  "unit-pressure",
+  "unit-area",
+  "unit-concentration",
+] as const;
 
-const unitKey = (pattern: string, before: boolean): string => `${before ? "<" : ">"}${pattern}`;
+const dimensionOf = (lexicon: string, entry: LexiconEntry): string => (entry.group === undefined ? lexicon : `${lexicon}:${entry.group}`);
+
+const unitKey = (dimension: string, pattern: string, before: boolean): string => `${dimension}\u0000${before ? "<" : ">"}${pattern}`;
+
+type Factors = { readonly pattern: string; readonly dimension: string; readonly before: boolean; readonly weights: readonly number[] };
 
 /** 単位ごとの、零点（unit-zero）と、要る文脈の語（unit-context の group がその単位の語）。 */
 export const measureUnitsOf = (doc: ProseDocument): MeasureUnit[] => {
   const zeros = new Map((doc.lexicons["unit-zero"] ?? []).map((entry) => [entry.pattern, entry.weight ?? 0]));
   const contexts = doc.lexicons["unit-context"] ?? [];
-  return MEASURE_DIMENSIONS.flatMap((dimension) => {
-    const factors = new Map<string, { pattern: string; before: boolean; weights: number[] }>();
-    (doc.lexicons[dimension] ?? []).forEach((entry) => {
+  return MEASURE_DIMENSIONS.flatMap((lexicon) => {
+    const factors = new Map<string, Factors>();
+    (doc.lexicons[lexicon] ?? []).forEach((entry) => {
       if (entry.weight === undefined) return;
       const before = entry.position === "before";
-      const key = unitKey(entry.pattern, before);
-      const found = factors.get(key) ?? { pattern: entry.pattern, before, weights: [] };
+      const dimension = dimensionOf(lexicon, entry);
+      const key = unitKey(dimension, entry.pattern, before);
+      const found = factors.get(key) ?? { pattern: entry.pattern, dimension, before, weights: [] };
       factors.set(key, { ...found, weights: [...found.weights, entry.weight] });
     });
-    return [...factors.values()].map(({ pattern, before, weights }) => ({
+    return [...factors.values()].map(({ pattern, dimension, before, weights }) => ({
       pattern,
       dimension,
       factors: weights,

package/src/facts/measures.ts

@@ -1,5 +1,5 @@
 import type { FactValue } from "./fact-values.ts";
-import { lineHasContext, standsAsUnitWord } from "./unit-word.ts";
+import { lineHasContext, runsIntoWord, standsAsUnitWord } from "./unit-word.ts";
 
 /**
  * 単位の付いた量（5 km、3000 m、1.5時間、2 GB、180℃、大さじ1）。単位は言語パッケージの語彙表から取り、量の種類（長さ、重さ…）と、基準の単位への
@@ -30,10 +30,10 @@ export type Measured = FactValue & {
 export type Tolerance = { readonly relative: number; readonly absolute: number };
 
 /**
- * 前に英字や数が続く数（v2、A4、1.2.3 の 2）と、分数の分母（1/2 の 2）は量ではない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。
+ * 前に英字や数が続く数（v2、A4、1.2.3 の 2）と、分数の分母（1/2 の 2）と、冪の指数（×10^4/µL の 4）は量ではない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。
  * 字や数のすぐ後ろでない負の符号は数に含める（-20 °C）。20-25°C の - は範囲の印。
  */
-const NUMBER = /(?<![\p{Script=Latin}\p{N}.,])(?<![0-9０-９][/／])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+const NUMBER = /(?<![\p{Script=Latin}\p{N}.,^])(?<![0-9０-９][/／])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
 const MINUS_SIGNS = new Set(["-", "−", "－"]);
 const BEFORE_SIGN = /[\p{L}\p{N}.,]/u;
 
@@ -60,18 +60,18 @@ const GAPS = new Set([" ", "-"]);
 type Found = { readonly unit: MeasureUnit; readonly start: number; readonly end: number };
 
 /**
- * 数のすぐ後ろ（空白かハイフン一つまで）の単位。長い単位から試す（「5分間」を 分 で切らない、min を m にしない）。
- * 単位の後ろに語が続く（5 miners）ものは、名前付きの値の終わり（fact-value-end）で落ちるので、ここでは見ない。
+ * 数のすぐ後ろ（空白かハイフン一つまで）の単位。長い単位から試す（「5分間」を 分 で切らない、min を m にしない）。一番長く書かれた単位が
+ * 語に続いていれば、短い単位にも読み替えない（"5 g/dLs" を 5 g にしない）。
  */
 const unitAfter = (source: string, start: number, end: number, units: readonly MeasureUnit[]): Found | undefined => {
   const gap = GAPS.has(source.charAt(end)) ? 1 : 0;
   const rest = source.slice(end + gap, end + gap + MAX_UNIT_LENGTH);
-  const unit = units.find(
-    (candidate) =>
-      !candidate.before &&
-      rest.startsWith(candidate.pattern) &&
-      standsAsUnitWord(candidate.pattern, candidate.context.length > 0, source.slice(end + gap + candidate.pattern.length)) &&
-      inContext(candidate, source, end),
+  const afterUnit = (candidate: MeasureUnit): string => source.slice(end + gap + candidate.pattern.length);
+  const written = units.filter((candidate) => !candidate.before && rest.startsWith(candidate.pattern));
+  const [longest] = written;
+  if (longest === undefined || runsIntoWord(longest.pattern, afterUnit(longest))) return undefined;
+  const unit = written.find(
+    (candidate) => standsAsUnitWord(candidate.pattern, candidate.context.length > 0, afterUnit(candidate)) && inContext(candidate, source, end),
   );
   return unit === undefined ? undefined : { unit, start, end: end + gap + unit.pattern.length };
 };

package/src/facts/qualified-labels.ts

@@ -0,0 +1,126 @@
+/**
+ * 条件の付いた名前（「待機期間（旅行キャンセル費用）」「旅行キャンセル費用の待機期間」"waiting period for cancellation cover"）を
+ * 一つの書き方（名前と条件）にする。語彙表の型は * が条件の位置: 「（*）」「*の」"(*)" "for *"。
+ * 条件の違う名前（待機期間（疾病）と待機期間（けが））と、条件の無い名前（待機期間）は別の名前のまま。
+ * 英語の "cancellation cover waiting period" は、同じ文書が "waiting period (cancellation cover)" とも書いたときだけ同じ名前。
+ */
+export type QualifierWords = {
+  /** 条件を書く型。* が条件。* が頭なら条件は名前の前（*の）、そうでなければ後ろ（（*）、for *）。 */
+  readonly templates: readonly string[];
+  /** 名前と条件の頭から落とす語（the, our）。 */
+  readonly determiners: readonly string[];
+};
+
+export type QualifiedLabel = { readonly head: string; readonly qualifier: string };
+
+const PLACEHOLDER = "*";
+const LETTER = /\p{L}/u;
+const LATIN_WORD = /^[a-z]+(?: [a-z]+)*$/u;
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const wordsOf = (text: string): string[] => text.split(/\s+/u).filter((word) => word !== "");
+
+const withoutDeterminers = (text: string, determiners: readonly string[]): string => {
+  const words = wordsOf(text);
+  const start = words.findIndex((word) => !determiners.includes(word));
+  return start === -1 ? "" : words.slice(start).join(" ");
+};
+
+const labelOf = (head: string, qualifier: string, words: QualifierWords): QualifiedLabel | undefined => {
+  const determiners = words.determiners.map(folded);
+  const label = { head: withoutDeterminers(head, determiners), qualifier: withoutDeterminers(qualifier, determiners) };
+  return LETTER.test(label.head) && LETTER.test(label.qualifier) ? label : undefined;
+};
+
+/** 英字の語の区切り（for、of）は、前後が空白のときだけ。最初のものから後ろが条件。 */
+const splitAtWord = (key: string, joiner: string): [string, string] | undefined => {
+  const at = key.indexOf(` ${joiner} `);
+  return at === -1 ? undefined : [key.slice(0, at), key.slice(at + joiner.length + 2)];
+};
+
+/** 記号の区切り（（）は、最後のものから後ろが条件。 */
+const splitAtMark = (key: string, open: string): [string, string] | undefined => {
+  const at = key.lastIndexOf(open);
+  return at <= 0 ? undefined : [key.slice(0, at), key.slice(at + open.length)];
+};
+
+/** 条件が名前の後ろの型（（*）、for *）。 */
+const qualifierAfter = (key: string, open: string, close: string): [string, string] | undefined => {
+  if (!key.endsWith(close)) return undefined;
+  const body = key.slice(0, key.length - close.length);
+  const trimmed = open.trim();
+  return LATIN_WORD.test(trimmed) ? splitAtWord(body, trimmed) : splitAtMark(body, open);
+};
+
+/** 条件が名前の前の型（*の）。最後のつなぎの語から後ろが名前。 */
+const qualifierBefore = (key: string, joiner: string): [string, string] | undefined => {
+  const at = key.lastIndexOf(joiner);
+  return at <= 0 ? undefined : [key.slice(at + joiner.length), key.slice(0, at)];
+};
+
+const splitBy = (key: string, template: string): [string, string] | undefined => {
+  const at = template.indexOf(PLACEHOLDER);
+  if (at === -1) return undefined;
+  const open = template.slice(0, at);
+  const close = template.slice(at + PLACEHOLDER.length);
+  if (open === "") return close === "" ? undefined : qualifierBefore(key, close);
+  return qualifierAfter(key, open, close);
+};
+
+/** 名前の key を、名前と条件に分ける。型に合わなければ undefined。語彙表の順に試す。 */
+export const qualifiedLabelOf = (key: string, words: QualifierWords): QualifiedLabel | undefined => {
+  const trimmed = folded(key).trim();
+  for (const template of words.templates.map(folded)) {
+    const parts = splitBy(trimmed, template);
+    const label = parts === undefined ? undefined : labelOf(parts[0], parts[1], words);
+    if (label !== undefined) return label;
+  }
+  return undefined;
+};
+
+const keyOfLabel = ({ head, qualifier }: QualifiedLabel): string => `${head} (${qualifier})`;
+
+/** 名前と条件を別々に持つ値（表の列の見出しと行の見出し）の key。どちらかに字が無ければ undefined。 */
+export const keyOfParts = (head: string, qualifier: string, words: QualifierWords): string | undefined => {
+  const spaced = (text: string): string => folded(text).replace(/\s+/gu, " ").trim();
+  const label = labelOf(spaced(head), spaced(qualifier), words);
+  return label === undefined ? undefined : keyOfLabel(label);
+};
+
+/** 条件の付いた名前は「名前 (条件)」に。条件の無い名前は書いたまま。 */
+export const qualifiedKeyOf = (key: string, words: QualifierWords): string => {
+  const label = qualifiedLabelOf(key, words);
+  return label === undefined ? key : keyOfLabel(label);
+};
+
+/** 前に置いた条件（cancellation cover waiting period）として読める条件か。語だけで、冠詞もつなぎの語も含まない。 */
+const isPremodifier = (qualifier: string, words: QualifierWords): boolean => {
+  const joiners = words.templates.map((template) => folded(template).replace(PLACEHOLDER, "").trim());
+  const determiners = words.determiners.map(folded);
+  return LATIN_WORD.test(qualifier) && wordsOf(qualifier).every((word) => !determiners.includes(word) && !joiners.includes(word));
+};
+
+/** 前に置いた書き方が、二つの名前と条件（claim limit (baggage) と limit (baggage claim)）に読めるものは、どちらにもしない。 */
+const unambiguous = (pairs: readonly [string, string][]): Map<string, string> => {
+  const targets = new Map<string, Set<string>>();
+  pairs.forEach(([surface, key]) => targets.set(surface, (targets.get(surface) ?? new Set<string>()).add(key)));
+  return new Map(pairs.filter(([surface]) => targets.get(surface)?.size === 1));
+};
+
+/**
+ * 文書の名前の key を一つの書き方に。条件を前に置いた名前（"cancellation cover waiting period"）は、同じ文書に同じ名前と条件の
+ * 型の書き方があるときだけ、それと同じ key にする。
+ */
+export const qualifiedKeys = (keys: readonly string[], words: QualifierWords): string[] => {
+  const labels = keys.map((key) => qualifiedLabelOf(key, words));
+  const premodified = unambiguous(
+    labels.flatMap((label): [string, string][] =>
+      label === undefined || !isPremodifier(label.qualifier, words) ? [] : [[`${label.qualifier} ${label.head}`, keyOfLabel(label)]],
+    ),
+  );
+  return keys.map((key, index) => {
+    const label = labels[index];
+    return label === undefined ? (premodified.get(key.trim()) ?? key) : keyOfLabel(label);
+  });
+};

package/src/facts/rate-values.ts

@@ -0,0 +1,117 @@
+import type { FactValue } from "./fact-values.ts";
+import { EDGE_MARKS, trimEndOf } from "./trim-marks.ts";
+
+/**
+ * 率（百分率）の値のまわりに書く、値を変えない語。期間（年3.6%、4.8% per year）、種類（固定、variable）、何に対する率
+ * （of the purchase price）、括弧の注記（3.6%（固定金利））。これらを越えた所で値が終わっていれば、率は名前の値として読む。
+ * 語彙表に無い語が続く率（3.6% of applicants、3.6%増）は、別の量の一部なので読まない。
+ * 期間・種類・対象は値の基準（basis）になり、両方に書いてあって違えば別の量として比べない（月0.5% と 年6%）。
+ * 語彙表に無い括弧の注記（(of applicants)、(men)）は、同じ注記の率とだけ比べる。何の率かを言っているかもしれない。
+ */
+export type RateWord = { readonly pattern: string; readonly group?: string | undefined; readonly position: "before" | "after" };
+
+export type RateWords = {
+  /** 百分率の単位（%、パーセント）。 */
+  readonly units: readonly string[];
+  /** 基準の語彙表ごとの語。鍵は基準の種類（period、kind、base）。 */
+  readonly notes: Readonly<Record<string, readonly RateWord[]>>;
+  /** 率のすぐ後ろで、値を言い終えて次の節を始める語句（and stays、and does not）。 */
+  readonly joiners: readonly string[];
+};
+
+/** 基準の種類と、その値（period:year）。 */
+export type RateBasis = readonly string[];
+
+const OPEN_BRACKETS: ReadonlySet<string> = new Set(["(", "（"]);
+const CLOSE_BRACKETS = /[)）]/u;
+const NESTED_OR_LINE = /[(（\n]/u;
+const SPACES = /^[ \t]*/u;
+const LATIN_LETTER = /[a-z]/iu;
+/** 語彙表に無い括弧の注記の基準。この基準だけは、片方に無くても食い違いとする。 */
+const NOTE = "note:";
+
+const normalized = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+export const isRate = (value: FactValue, words: RateWords): boolean =>
+  value.kind === "quantity" && words.units.some((unit) => normalized(unit) === normalized(value.unit));
+
+const basisOf = (dimension: string, word: RateWord): RateBasis => (word.group === undefined ? [] : [`${dimension}:${word.group}`]);
+
+type NoteMatch = { readonly length: number; readonly basis: RateBasis };
+
+/** 英字で終わる語は、語の途中で切れていないこと（a year を a yearly の頭として読まない）。 */
+const endsWord = (text: string, length: number): boolean => !(LATIN_LETTER.test(text.charAt(length - 1)) && LATIN_LETTER.test(text.charAt(length)));
+
+const longestOf = (matches: readonly NoteMatch[]): NoteMatch | undefined =>
+  matches.reduce<NoteMatch | undefined>((longest, match) => (longest === undefined || match.length > longest.length ? match : longest), undefined);
+
+/** 基準の語のうち、置く側が position のもの（undefined ならどちらでも）を、語彙表の種類と組にして。 */
+const notesAt = (words: RateWords, position: RateWord["position"] | undefined): { readonly dimension: string; readonly word: RateWord }[] =>
+  Object.entries(words.notes).flatMap(([dimension, entries]) =>
+    entries.filter((word) => position === undefined || word.position === position).map((word) => ({ dimension, word })),
+  );
+
+/** text の頭に置いた基準の語のうち一番長いもの。 */
+const noteAtStart = (text: string, words: RateWords, position: RateWord["position"] | undefined): NoteMatch | undefined =>
+  longestOf(
+    notesAt(words, position)
+      .filter(({ word }) => normalized(text.slice(0, word.pattern.length)) === normalized(word.pattern) && endsWord(text, word.pattern.length))
+      .map(({ dimension, word }): NoteMatch => ({ length: word.pattern.length, basis: basisOf(dimension, word) })),
+  );
+
+/** 頭の括弧の注記。中身が基準の語そのもの（（固定金利）、(fixed)）なら、その基準も。行をまたぐ括弧や入れ子は注記にしない。 */
+const bracketAtStart = (text: string, words: RateWords): NoteMatch | undefined => {
+  if (!OPEN_BRACKETS.has(text.charAt(0))) return undefined;
+  const close = text.search(CLOSE_BRACKETS);
+  const inside = close === -1 ? "" : text.slice(1, close);
+  if (close === -1 || NESTED_OR_LINE.test(inside)) return undefined;
+  const whole = noteAtStart(inside, words, undefined);
+  return { length: close + 1, basis: whole?.length === inside.length ? whole.basis : [`${NOTE}${normalized(inside).trim()}`] };
+};
+
+export type RateTail = { readonly end: number; readonly basis: RateBasis };
+
+/** 率の後ろの、値を変えない語と括弧の注記を越えた所と、そこまでに書いた基準。 */
+const tailFrom = (source: string, tail: RateTail, words: RateWords): RateTail => {
+  const text = source.slice(tail.end).replace(SPACES, "");
+  const note = bracketAtStart(text, words) ?? noteAtStart(text, words, "after");
+  if (note === undefined) return tail;
+  return tailFrom(source, { end: source.length - text.length + note.length, basis: [...tail.basis, ...note.basis] }, words);
+};
+
+export const rateTail = (source: string, value: FactValue, words: RateWords): RateTail => tailFrom(source, { end: value.end, basis: [] }, words);
+
+export type RateHead = { readonly head: string; readonly basis: RateBasis };
+
+/** 率の前の期間の語（年3.6% の 年）を、名前の側から外したものと、その基準。 */
+export const rateHead = (head: string, words: RateWords): RateHead => {
+  const trimmed = trimEndOf(head, EDGE_MARKS);
+  const found = longestOf(
+    notesAt(words, "before")
+      .filter(({ word }) => normalized(trimmed.slice(-word.pattern.length)) === normalized(word.pattern))
+      .map(({ dimension, word }): NoteMatch => ({ length: word.pattern.length, basis: basisOf(dimension, word) })),
+  );
+  if (found === undefined) return { head, basis: [] };
+  return { head: trimEndOf(trimmed.slice(0, trimmed.length - found.length), EDGE_MARKS), basis: found.basis };
+};
+
+/** 率の後ろが、値を言い終えて次の節を始める語句（4.5% and does not change）。語句の後ろは語の切れ目。 */
+export const joinsNextClause = (source: string, end: number, words: RateWords): boolean => {
+  const text = source.slice(end).replace(SPACES, "");
+  return words.joiners.some((phrase) => normalized(text.slice(0, phrase.length)) === normalized(phrase) && endsWord(text, phrase.length));
+};
+
+const dimensionOf = (entry: string): string => entry.slice(0, entry.indexOf(":") + 1);
+
+const notesOf = (basis: RateBasis): string =>
+  basis
+    .filter((entry) => entry.startsWith(NOTE))
+    .toSorted((left, right) => left.localeCompare(right, "en"))
+    .join("\u0000");
+
+/** 二つの値の基準が食い違わないか。同じ種類の基準を両方に書いて違うか、語彙表に無い注記が揃わないときに食い違う。 */
+export const basesAgree = (left: RateBasis | undefined, right: RateBasis | undefined): boolean => {
+  const [ours, theirs] = [left ?? [], right ?? []];
+  if (notesOf(ours) !== notesOf(theirs)) return false;
+  return ours.every((entry) => !theirs.some((other) => dimensionOf(other) === dimensionOf(entry) && other !== entry));
+};