chaffjs 0.30.0 → 0.32.0

package/src/facts/unit-conflicts.ts

@@ -1,14 +1,16 @@
 import type { ScopedFact } from "./fact-scope.ts";
 import { sameMeasure, type Measured } from "./measures.ts";
+import { toleranceOf } from "./unit-tolerance.ts";
+import { precisionTolerance, writtenHalfStep } from "./written-precision.ts";
+import { approximateTolerance } from "./approximate-tolerance.ts";
 
 /**
  * 同じ名前の量を、違う単位で書いて、換算すると合わない（「距離：5 km」と「距離：3000 m」）。比べるのは同じ範囲の、同じ種類の量で、
- * 単位が違うものだけ。同じ単位どうしの食い違いは fact-conflict が見る。丸めた書き方（1 mile と 1.6 km）は、差が TOLERANCE 以内なら合う。
+ * 単位が違うものだけ。同じ単位どうしの食い違いは fact-conflict が見る。丸めた書き方（1 mile と 1.6 km）は、差が量の種類ごとの許す差（unit-tolerance）以内なら合う。
+ * 小数で書いた量は、書いた桁の半分までの差も合う（1.2 kg と 1,250 g）。目安の量（約1 kg）は整数でも書いた桁の半分まで合う。
  */
 export type UnitConflict = { readonly fact: ScopedFact; readonly measured: Measured; readonly other: Measured };
 
-const TOLERANCE = 0.02;
-
 const groupKey = (fact: ScopedFact): string => `${fact.scope}\u0000${fact.key}`;
 
 type Read = { readonly fact: ScopedFact; readonly measured: Measured };
@@ -17,22 +19,33 @@ type Read = { readonly fact: ScopedFact; readonly measured: Measured };
  * 一つの種類（長さなら長さ）の量のうち、前にある単位の違う量のどれとも換算して合わないもの。どれか一つと合えば、食い違いは同じ単位
  * どうし（3 km と 5 km）の側にあり、fact-conflict が見る。
  */
-const conflictsInDimension = (reads: readonly Read[]): UnitConflict[] =>
+const conflictsInDimension = (reads: readonly Read[], halfStepOf: (measured: Measured) => number): UnitConflict[] =>
   reads.flatMap(({ fact, measured }, index) => {
     const others = reads.slice(0, index).filter((earlier) => earlier.measured.unit !== measured.unit);
     const [first] = others;
-    if (first === undefined || others.some((earlier) => sameMeasure(earlier.measured, measured, TOLERANCE))) return [];
+    const agrees = (earlier: Read): boolean => {
+      const written = precisionTolerance(toleranceOf(measured.dimension), [halfStepOf(earlier.measured), halfStepOf(measured)]);
+      const approximate = [earlier, { fact, measured }].filter((read) => read.fact.approximate === true).map((read) => read.measured);
+      return sameMeasure(earlier.measured, measured, approximateTolerance(written, approximate));
+    };
+    if (first === undefined || others.some(agrees)) return [];
     return [{ fact, measured, other: first.measured }];
   });
 
-const conflictsIn = (reads: readonly Read[]): UnitConflict[] => {
+const conflictsIn = (reads: readonly Read[], halfStepOf: (measured: Measured) => number): UnitConflict[] => {
   if (reads.some(({ fact }) => fact.record)) return [];
   const dimensions = [...new Set(reads.map(({ measured }) => measured.dimension))];
-  return dimensions.flatMap((dimension) => conflictsInDimension(reads.filter(({ measured }) => measured.dimension === dimension)));
+  return dimensions.flatMap((dimension) =>
+    conflictsInDimension(
+      reads.filter(({ measured }) => measured.dimension === dimension),
+      halfStepOf,
+    ),
+  );
 };
 
 /** 範囲と名前ごとに、最初の量と単位の違う量を換算して比べる。 */
-export const unitConflicts = (facts: readonly ScopedFact[], measuredOf: (fact: ScopedFact) => Measured | undefined): UnitConflict[] => {
+export const unitConflicts = (facts: readonly ScopedFact[], measuredOf: (fact: ScopedFact) => Measured | undefined, source: string): UnitConflict[] => {
+  const halfStepOf = (measured: Measured): number => writtenHalfStep(source.slice(measured.start, measured.end), measured.factors);
   const groups = new Map<string, Read[]>();
   facts.forEach((fact) => {
     const measured = measuredOf(fact);
@@ -41,5 +54,5 @@ export const unitConflicts = (facts: readonly ScopedFact[], measuredOf: (fact: S
     if (group === undefined) groups.set(groupKey(fact), [{ fact, measured }]);
     else group.push({ fact, measured });
   });
-  return [...groups.values()].flatMap(conflictsIn);
+  return [...groups.values()].flatMap((reads) => conflictsIn(reads, halfStepOf));
 };

package/src/facts/unit-equivalents.ts

@@ -0,0 +1,70 @@
+import { sameMeasure, sameUnit, type Measured, type Tolerance } from "./measures.ts";
+import { toleranceOf } from "./unit-tolerance.ts";
+
+/**
+ * 一つの量を二つの単位で並べて書いた所（180℃（350°F）、300 kPa (about 44 psi)）。括弧の中の量は、外の量を換算して丸めたもの。
+ * 括弧は量のすぐ後ろ（空白一つまで）で、中は前置き（約、about）を一つまで挟んですぐ量。量の後ろに字や数が続く括弧は、換算ではない。
+ * どちらが元の量かは分からないので、二つの数をそれぞれの桁で丸めたものとして比べる。
+ */
+export type UnitPair = { readonly measured: Measured; readonly other: Measured };
+
+const OPENERS = ["（", "("];
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const LATIN_LETTER = /\p{Script=Latin}/u;
+const DECIMALS = /[.．]([0-9０-９]+)/u;
+const DIGITS = /[0-9０-９]+/u;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+const skipSpace = (source: string, offset: number): number => (source.charAt(offset) === " " ? offset + 1 : offset);
+
+/** 前置きの後ろ。英字で終わる前置き（about）は、後ろに英字が続けば前置きではない（aboutness）。 */
+const afterHedge = (source: string, offset: number, hedges: readonly string[]): number => {
+  const rest = source.slice(offset).toLowerCase();
+  const hedge = hedges.find(
+    (word) => rest.startsWith(word.toLowerCase()) && !(LATIN_LETTER.test(word.slice(-1)) && LATIN_LETTER.test(rest.charAt(word.length))),
+  );
+  return hedge === undefined ? offset : skipSpace(source, offset + hedge.length);
+};
+
+/** 量の後ろの括弧の中で、換算した量が始まる所。括弧が無ければ undefined。 */
+const insideBracket = (source: string, end: number, hedges: readonly string[]): number | undefined => {
+  const open = skipSpace(source, end);
+  return OPENERS.includes(source.charAt(open)) ? afterHedge(source, open + 1, hedges) : undefined;
+};
+
+/**
+ * 書いた数を丸めた桁の半分を、基準の単位で（44 psi なら 0.5 psi、1.6 km なら 0.05 km）。0 で終わる整数は、最後の 0 の一つ上の桁で
+ * 丸めたとみなす（100 miles は 10 の位で ±5）。0 一つ（60、180）は 1 の位のまま。
+ */
+const trailingZeros = (digits: string): number => {
+  const reversed = [...digits.normalize("NFKC")].reverse();
+  const nonZero = reversed.findIndex((digit) => digit !== "0");
+  return nonZero === -1 ? reversed.length : nonZero;
+};
+
+const halfRoundingStep = (source: string, measured: Measured): number => {
+  const written = source.slice(measured.start, measured.end).replace(/,/gu, "");
+  const decimals = DECIMALS.exec(written)?.[1]?.length;
+  const zeros = trailingZeros(DIGITS.exec(written)?.[0] ?? "");
+  const exponent = decimals === undefined ? Math.max(0, zeros - 1) : -decimals;
+  return HALF * DECIMAL_BASE ** exponent * Math.min(...measured.factors);
+};
+
+/** 二つの数が、同じ値をそれぞれの桁で丸めたものでありうるなら合う。温度は、オーブンの目盛りの差（unit-tolerance）までも合う。 */
+const pairTolerance = (source: string, first: Measured, second: Measured): Tolerance => {
+  const tolerance = toleranceOf(second.dimension);
+  return { relative: tolerance.relative, absolute: Math.max(tolerance.absolute, halfRoundingStep(source, first) + halfRoundingStep(source, second)) };
+};
+
+/** 二つの単位で並べた量のうち、換算すると合わないもの。 */
+export const unitPairs = (source: string, measured: readonly Measured[], hedges: readonly string[]): UnitPair[] => {
+  const byStart = new Map(measured.map((value) => [value.start, value]));
+  return measured.flatMap((other): UnitPair[] => {
+    const start = insideBracket(source, other.end, hedges);
+    const value = start === undefined ? undefined : byStart.get(start);
+    if (value === undefined || value.dimension !== other.dimension || sameUnit(value, other)) return [];
+    if (LETTER_OR_DIGIT.test(source.charAt(value.end))) return [];
+    return sameMeasure(other, value, pairTolerance(source, other, value)) ? [] : [{ measured: value, other }];
+  });
+};

package/src/facts/unit-tolerance.ts

@@ -0,0 +1,17 @@
+import type { Tolerance } from "./measures.ts";
+
+/** 丸めた書き方（1 mile と 1.6 km、300 kPa と 44 psi）を合うとみなす差。大きいほうの値の 2%。 */
+const ROUNDING_SHARE = 0.02;
+
+/**
+ * 温度は割合では比べられない（0 ℃ の 2% は 0）。オーブンの換算表は 25 °F 刻みの目盛りに丸める（170 ℃ と 325 °F は 13 °F 違う）ので、
+ * 一目盛りより小さい 15 °F までの差は合うとみなす。
+ */
+const OVEN_ROUNDING_FAHRENHEIT = 15;
+const CELSIUS_PER_FAHRENHEIT_DEGREE = 5 / 9;
+
+const DEFAULT_TOLERANCE: Tolerance = { relative: ROUNDING_SHARE, absolute: 0 };
+const TEMPERATURE_TOLERANCE: Tolerance = { relative: 0, absolute: OVEN_ROUNDING_FAHRENHEIT * CELSIUS_PER_FAHRENHEIT_DEGREE };
+
+/** 量の種類（語彙表の id）ごとの、換算して合うとみなす差。 */
+export const toleranceOf = (dimension: string): Tolerance => (dimension === "unit-temperature" ? TEMPERATURE_TOLERANCE : DEFAULT_TOLERANCE);

package/src/facts/unit-word.ts

@@ -0,0 +1,48 @@
+const LATIN_WORD = /^\p{Script=Latin}+$/u;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+/** 単位のすぐ後ろに、数（空白一つまで）か、ハイフンでつながる語が続く。 */
+const CONTINUED = /^(?:[ \t]?[0-9０-９]|-[\p{L}\p{N}])/u;
+
+const ENDS_LATIN = /\p{Script=Latin}$/u;
+const STARTS_LATIN = /^\p{Script=Latin}/u;
+
+const isLatinWord = (word: string): boolean => LATIN_WORD.test(word);
+
+/** 英字の語が、語として行にあるか（"x" は "box" の中では数えない）。 */
+const hasWord = (line: string, word: string): boolean => {
+  let from = line.indexOf(word);
+  while (from !== -1) {
+    const end = from + word.length;
+    if (!WORD_CHAR.test(line.charAt(from - 1)) && !WORD_CHAR.test(line.charAt(end))) return true;
+    from = line.indexOf(word, from + 1);
+  }
+  return false;
+};
+
+/** 単位に要る文脈の語が、行にどれかあるか。英字の語は語として探し、ほかの字（オーブン、×）は字の並びとして探す。大文字と小文字は区別しない。 */
+export const lineHasContext = (line: string, words: readonly string[]): boolean => {
+  const lowered = line.toLowerCase();
+  return words.some((word) => {
+    const target = word.toLowerCase();
+    return isLatinWord(target) ? hasWord(lowered, target) : lowered.includes(target);
+  });
+};
+
+/**
+ * 文脈の要る英字の単位（"in"）は、その言語のふつうの語でもある。単位として読むのは、語がそこで終わり（"5 interns" の in ではない）、
+ * 後ろに数もハイフンでつながる語も続かない（"1 in 3"、"2-in-1"）ときだけ。文脈の要らない単位と、英字でない単位（度）は、この形を見ない。
+ */
+export const standsAsUnitWord = (pattern: string, needsContext: boolean, after: string): boolean => {
+  if (!needsContext || !isLatinWord(pattern)) return true;
+  return !WORD_CHAR.test(after.charAt(0)) && !CONTINUED.test(after);
+};
+
+const ENDS_DIGIT = /\d$/u;
+const STARTS_WORD = /^[\p{Script=Latin}\p{N}]/u;
+
+/**
+ * 英字で終わる単位の後ろに英字が続けば、単位ではなく語の頭（"20 to" の t、"3 tons" の t、"5 miners" の min、"120 mmHg" の mm）。
+ * 数字で終わる単位（m2）は、後ろに英字か数字が続けば語の頭（"3 m23"、"5 m2x"）。
+ */
+export const runsIntoWord = (pattern: string, after: string): boolean =>
+  (ENDS_LATIN.test(pattern) && STARTS_LATIN.test(after)) || (ENDS_DIGIT.test(pattern) && STARTS_WORD.test(after));

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

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

package/src/facts/whole-counts.ts

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

package/src/facts/written-precision.ts

@@ -0,0 +1,23 @@
+import type { Tolerance } from "./measures.ts";
+
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const DECIMALS = /[.．]([0-9０-９]+)/u;
+/** 端の値（1.2 kg と 1,250 g）が浮動小数の誤差で外れないための余り。 */
+const FLOAT_SLACK = 1 + 1e-9;
+
+/**
+ * 小数で書いた量が言える幅の半分を、基準の単位で（1.2 kg は 1.15〜1.25 kg なので 0.05 kg）。書き手は小数点の後ろの最後の桁で丸めて
+ * 書いている。整数（410 g、1 mile）は 0：末尾の 0 が丸めか（1,200 g）は書き方から分からず、仕様の整数はふつう書いたとおりの値なので、
+ * 量の種類ごとの差（unit-tolerance）だけで比べる。
+ */
+export const writtenHalfStep = (written: string, factors: readonly number[]): number => {
+  const decimals = DECIMALS.exec(written)?.[1]?.length;
+  return decimals === undefined || factors.length === 0 ? 0 : HALF * DECIMAL_BASE ** -decimals * Math.max(...factors) * FLOAT_SLACK;
+};
+
+/** 二つの量を比べるときの、合うとみなす差。粗いほうの量の書いた桁の半分が、量の種類ごとの差より広ければそちら。 */
+export const precisionTolerance = (tolerance: Tolerance, halfSteps: readonly number[]): Tolerance => ({
+  relative: tolerance.relative,
+  absolute: Math.max(tolerance.absolute, ...halfSteps),
+});

package/src/kana-spelling.ts

@@ -22,6 +22,31 @@ export const kanjiSkeleton = (text: string): string => [...text.matchAll(KANJI)]
 export const dropsOkurigana = (spelling: string, spellings: readonly string[]): boolean =>
   spelling !== "" && kanjiSkeleton(spelling) === spelling && spellings.some((other) => other !== spelling && kanjiSkeleton(other) === spelling);
 
+const KANJI_OR_KANA_RUN = /[\p{Script=Han}々]|[^\p{Script=Han}々]+/gu;
+
+/**
+ * Whether a spelling writes in kana part of the word another spells with more kanji (かたくり粉 beside 片栗粉, とり扱い beside
+ * 取り扱い): every kanji it keeps stands where the other has it, each kana run stands for something there, and the other keeps
+ * more kanji. Only the letters are compared; the caller has already matched the readings.
+ */
+export const isKanaForKanji = (partial: string, full: string): boolean => {
+  const kept = kanjiSkeleton(partial);
+  if (kept === "" || kept === partial || [...kanjiSkeleton(full)].length <= [...kept].length) return false;
+  const pattern = [...partial.matchAll(KANJI_OR_KANA_RUN)].map(([part]) => (kanjiSkeleton(part) === part ? part : ".+")).join("");
+  return new RegExp(`^${pattern}$`, "u").test(full);
+};
+
+/**
+ * The kanji a spelling is keyed by among spellings of one reading: its own, or, when it writes part of the word in kana
+ * (かたくり粉), the kanji of the spelling with more kanji it stands for (片栗粉). When it could stand for two (two words of one
+ * reading), its own.
+ */
+export const kanjiKeyAmong = (spelling: string, spellings: readonly string[]): string => {
+  const fuller = new Set(spellings.filter((other) => isKanaForKanji(spelling, other)).map(kanjiSkeleton));
+  const [only] = fuller;
+  return fuller.size === 1 && only !== undefined ? only : kanjiSkeleton(spelling);
+};
+
 /** The length, in UTF-16 units, of the start both strings share, compared character by character (𠮟 is one character, two units). */
 const sharedPrefixLength = (left: string, right: string): number => {
   const [leftChars, rightChars] = [[...left], [...right]];

package/src/model-codes.ts

@@ -0,0 +1,104 @@
+// 型番の書き分け（KM-SP300 と KM-SP-300、KMSP300、km-sp300）。型番と読むのは、文書の題か型番の欄（語彙表 model-code-label）の後ろに
+// 書いた、英大文字と数字を合わせた語だけ。ハイフン・空白・大小・幅を除いて同じ字の並びになるものを同じ型番と見る。字や数の違う
+// 型番（KM-SP300 と KM-SP310）は別の型番なので比べない。
+
+export type ModelCode = { readonly offset: number; readonly surface: string };
+export type ModelCodeVariant = { readonly code: ModelCode; readonly usual: string };
+
+/** 型番と読む字の数（ハイフンと空白を除く）の下限。S3 や v2 は短すぎて型番か分からない。 */
+const MIN_KEY_LENGTH = 4;
+
+const ALNUM = "A-Za-z0-9Ａ-Ｚａ-ｚ０-９";
+const HYPHENS = "\\-‐‑－";
+/** 型番の字の間に書いてよい区切り。 */
+const SEPARATOR = `[${HYPHENS} ]?`;
+/** 型番の前に来れば、より長い語・パス・URL・ファイル名・色（#FF0000）の一部。 */
+const BEFORE_OTHER = new RegExp(`[${ALNUM}${HYPHENS}_./\\\\@=#]$`, "u");
+/** 型番の後ろに来れば、より長い語・パス・ファイル名（.pdf）・版（.2）の一部。 */
+const AFTER_OTHER = new RegExp(`^(?:[${ALNUM}${HYPHENS}_/\\\\]|\\.[${ALNUM}])`, "u");
+const CODE_SHAPE = new RegExp(`[${ALNUM}]+(?:[${HYPHENS}][${ALNUM}]+)*`, "gu");
+const URL = /(?:https?:\/\/|www\.)[^\s<>"'）)」]+/gu;
+
+/** ハイフン・空白・大小・幅を除いた字の並び。同じ並びなら同じ型番。 */
+export const modelCodeKey = (surface: string): string =>
+  surface
+    .normalize("NFKC")
+    .toLowerCase()
+    .replaceAll(/[\s\-‐‑]/gu, "");
+
+/** 英大文字と数字を両方含み、英小文字を含まない、短すぎない語。iOS17 や v1 は型番と読まない。 */
+export const isModelCodeShape = (surface: string): boolean => {
+  const key = modelCodeKey(surface);
+  const ascii = surface.normalize("NFKC");
+  return key.length >= MIN_KEY_LENGTH && /[A-Z]/u.test(ascii) && /\d/u.test(ascii) && !/[a-z]/u.test(ascii);
+};
+
+const standsAlone = (text: string, start: number, end: number): boolean =>
+  !BEFORE_OTHER.test(text.slice(Math.max(0, start - 1), start)) && !AFTER_OTHER.test(text.slice(end, end + 2));
+
+/** 範囲の中の、型番の形をした語。 */
+export const codesInTitle = (text: string, start: number, end: number): ModelCode[] =>
+  [...text.slice(start, end).matchAll(CODE_SHAPE)]
+    .map((match) => ({ offset: start + match.index, surface: match[0] }))
+    .filter((code) => isModelCodeShape(code.surface) && standsAlone(text, code.offset, code.offset + code.surface.length));
+
+const escaped = (pattern: string): string => pattern.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** 欄の語の直後（「：」や空白を挟んでよい）に書いた、型番の形をした語。英字の欄の語は大小を問わず、語の途中からは読まない。 */
+export const codesAfterLabels = (text: string, labels: readonly string[]): ModelCode[] => {
+  if (labels.length === 0) return [];
+  const alternatives = labels.toSorted((left, right) => right.length - left.length).map(escaped);
+  const pattern = new RegExp(
+    `(?<![A-Za-z])(?:${alternatives.join("|")})(?![A-Za-z])[ \\t]*[:：]?[ \\t\\u3000]*([${ALNUM}]+(?:[${HYPHENS}][${ALNUM}]+)*)`,
+    "giu",
+  );
+  return [...text.matchAll(pattern)]
+    .map((match) => ({ offset: match.index + match[0].length - (match[1] ?? "").length, surface: match[1] ?? "" }))
+    .filter((code) => isModelCodeShape(code.surface) && standsAlone(text, code.offset, code.offset + code.surface.length));
+};
+
+/** 一つの字の、大小と全角の形。 */
+const charClass = (char: string): string => {
+  const forms = new Set([char, char.toUpperCase(), char.toLowerCase()].flatMap((form) => [form, String.fromCodePoint((form.codePointAt(0) ?? 0) + 0xfee0)]));
+  return `[${[...forms].join("")}]`;
+};
+
+const urlSpans = (text: string): { start: number; end: number }[] =>
+  [...text.matchAll(URL)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** 字の並びが key と同じになる語のすべて。字の間にはハイフンか空白を一つまで挟んでよい。URL の中は読まない。 */
+export const codesWithKey = (text: string, key: string): ModelCode[] => {
+  const pattern = new RegExp([...key].map(charClass).join(SEPARATOR), "gu");
+  const urls = urlSpans(text);
+  return [...text.matchAll(pattern)]
+    .map((match) => ({ offset: match.index, surface: match[0] }))
+    .filter((code) => standsAlone(text, code.offset, code.offset + code.surface.length))
+    .filter((code) => !urls.some((url) => url.start <= code.offset && code.offset < url.end));
+};
+
+const countsOf = (codes: readonly ModelCode[]): Map<string, number> =>
+  codes.reduce((counts, code) => counts.set(code.surface, (counts.get(code.surface) ?? 0) + 1), new Map<string, number>());
+
+/** 一番多く書いた形。数が同じなら、題か欄に先に書いた形。 */
+const usualOf = (codes: readonly ModelCode[], anchor: string): string => {
+  const counts = countsOf(codes);
+  const most = Math.max(...counts.values());
+  return (counts.get(anchor) ?? 0) === most ? anchor : ([...counts].find(([, count]) => count === most)?.[0] ?? anchor);
+};
+
+/** 一つの型番の、少ないほうの形。型番が二度以上出てこなければ、比べるものが無い。 */
+const variantsOfKey = (text: string, anchor: ModelCode): ModelCodeVariant[] => {
+  const codes = codesWithKey(text, modelCodeKey(anchor.surface));
+  if (codes.length < 2) return [];
+  const usual = usualOf(codes, anchor.surface);
+  return codes.filter((code) => code.surface !== usual).map((code) => ({ code, usual }));
+};
+
+/**
+ * 文書の型番（題か欄に書いたもの）を、ほかの所で別の形に書いた所。anchors は文書の順。同じ字の並びの型番は一度だけ見る。
+ */
+export const modelCodeVariants = (text: string, anchors: readonly ModelCode[]): ModelCodeVariant[] => {
+  const keys = anchors.map((anchor) => modelCodeKey(anchor.surface));
+  const firstPerKey = anchors.filter((_, index) => keys.indexOf(keys[index] ?? "") === index);
+  return firstPerKey.flatMap((anchor) => variantsOfKey(text, anchor)).toSorted((left, right) => left.code.offset - right.code.offset);
+};