chaffjs 0.18.0 → 0.20.0

package/src/extension/returned-findings.ts

@@ -0,0 +1,62 @@
+import type { Finding, Sentence } from "../plugin.ts";
+
+// What a plugin's detector returned, checked and turned into chaff's findings. Anything else than a list of
+// { start, end?, values? } inside the document is refused as a whole, with what was wrong: a rule that half works
+// would report some places and silently drop others. Pure.
+
+/** What was wrong, at which finding (from 1; 0 for the whole return), and what was there instead. */
+export type ShapeProblem = {
+  readonly kind: "not-a-list" | "not-a-finding" | "bad-start" | "bad-end" | "bad-values";
+  readonly index: number;
+  readonly written: string;
+};
+
+export type Returned = { readonly findings: readonly Finding[] } | { readonly problem: ShapeProblem };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** What came back instead of a list, in a few words: "a Promise", "undefined", "an object". */
+export const describeValue = (value: unknown): string => {
+  if (value === null || value === undefined) return String(value);
+  if (value instanceof Promise) return "a Promise";
+  if (Array.isArray(value)) return "a list";
+  return typeof value === "object" ? "an object" : `a ${typeof value}`;
+};
+
+const isOffsetIn = (value: unknown, low: number, high: number): value is number =>
+  typeof value === "number" && Number.isInteger(value) && value >= low && value <= high;
+
+const isValue = (value: unknown): value is string | number => typeof value === "string" || (typeof value === "number" && Number.isFinite(value));
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** The sentence the finding is in, or the line when it is in none (a heading, a table). */
+const quoteAt = (source: string, sentences: readonly Sentence[], offset: number): string => {
+  const sentence = sentences.find((entry) => entry.span.start <= offset && offset < entry.span.end);
+  if (sentence !== undefined) return sentence.text.trim();
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  const lineEnd = source.indexOf("\n", offset);
+  return source.slice(lineStart, lineEnd === -1 ? source.length : lineEnd).trim();
+};
+
+type Checked = { readonly finding: Finding } | { readonly problem: ShapeProblem };
+
+const checkedFinding = (entry: unknown, index: number, source: string, sentences: readonly Sentence[]): Checked => {
+  if (!isRecord(entry)) return { problem: { kind: "not-a-finding", index, written: describeValue(entry) } };
+  const { start, end = start, values = {} } = entry;
+  if (!isOffsetIn(start, 0, source.length)) return { problem: { kind: "bad-start", index, written: printed(start) } };
+  if (!isOffsetIn(end, start, source.length)) return { problem: { kind: "bad-end", index, written: printed(end) } };
+  if (!isRecord(values) || !Object.values(values).every(isValue)) return { problem: { kind: "bad-values", index, written: printed(values) } };
+  const filled = { matched: source.slice(start, end), ...values, offset: start };
+  return { finding: { rule: "", severity: "warning", line: 0, column: 0, quote: quoteAt(source, sentences, start), values: filled } };
+};
+
+/** The findings a detector returned, placed in the document, or the first thing wrong with them. index counts from 1. */
+export const returnedFindings = (returned: unknown, source: string, sentences: readonly Sentence[]): Returned => {
+  if (!Array.isArray(returned)) return { problem: { kind: "not-a-list", index: 0, written: describeValue(returned) } };
+  // Array.from reads a hole in a sparse list as undefined, so it is refused rather than skipped.
+  const checked = Array.from(returned, (entry: unknown, at) => checkedFinding(entry, at + 1, source, sentences));
+  const wrong = checked.find((entry) => "problem" in entry);
+  if (wrong !== undefined && "problem" in wrong) return { problem: wrong.problem };
+  return { findings: checked.flatMap((entry) => ("finding" in entry ? [entry.finding] : [])) };
+};

package/src/extension/rule-export.ts

@@ -0,0 +1,23 @@
+import { API_VERSION } from "../api.ts";
+import { describeValue } from "./returned-findings.ts";
+import type { UntrustedDetector } from "./module-detector.ts";
+
+// What a type: module file exports, read as a detector. The default export is the detector itself, or a rule made with
+// defineRule ({ apiVersion, detect }). A function carries no version and is read against this chaff's API; a rule that
+// names another version is refused, since its detector expects another document. Pure.
+
+/** bad-export: detail says what was exported instead. api-version: detail is the version the rule names. */
+export type ExportProblem = { readonly kind: "bad-export" | "api-version"; readonly detail: string };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isDetector = (value: unknown): value is UntrustedDetector => typeof value === "function";
+
+/** The detector a module's default export gives, or what is wrong with it. */
+export const detectorExport = (exported: unknown): { readonly detect: UntrustedDetector } | { readonly problem: ExportProblem } => {
+  if (isDetector(exported)) return { detect: exported };
+  if (!isRecord(exported) || !isDetector(exported["detect"])) return { problem: { kind: "bad-export", detail: describeValue(exported) } };
+  const version = exported["apiVersion"];
+  if (version !== undefined && version !== API_VERSION) return { problem: { kind: "api-version", detail: JSON.stringify(version) ?? describeValue(version) } };
+  return { detect: exported["detect"] };
+};

package/src/facts/fact-conflicts.ts

@@ -0,0 +1,64 @@
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+import type { ScopedFact } from "./fact-scope.ts";
+
+/**
+ * 同じ名前に違う値。比べるのは同じ種類で比べられる値どうし（同じ単位の数量、重なる細かさの日付、名前）。
+ * 一つの範囲の中で値が二通りなら、最初に書いた値と違うほうを言う。三通り以上なら、催しごとに並べた一覧と読んで言わない。
+ * 要約や冒頭の値は、本文の同じ名前の値と比べる。本文の値が一通りに揃っていて、要約の値がそれと違うときだけ言う。
+ */
+export type FactConflict = { readonly fact: ScopedFact; readonly other: FactValue };
+
+const MAX_DISTINCT = 2;
+
+const groupBy = <T>(items: readonly T[], keyOf: (item: T) => string): T[][] => {
+  const groups = new Map<string, T[]>();
+  items.forEach((item) => {
+    const key = keyOf(item);
+    const group = groups.get(key);
+    if (group === undefined) groups.set(key, [item]);
+    else group.push(item);
+  });
+  return [...groups.values()];
+};
+
+/** 互いに違う値。同じ値（3,000円と3000円、10月5日と2026年10月5日）は一つに数える。 */
+const distinctValues = (values: readonly FactValue[]): FactValue[] =>
+  values.reduce<FactValue[]>((kept, value) => (kept.some((seen) => sameValue(seen, value)) ? kept : [...kept, value]), []);
+
+/** 互いに比べられる値の組に分ける（単位ごと、日付の細かさごと）。比べられない値は、別の組で比べる。 */
+const comparableClasses = (facts: readonly ScopedFact[]): ScopedFact[][] =>
+  facts.reduce<ScopedFact[][]>((classes, fact) => {
+    const home = classes.find((members) => members[0] !== undefined && comparable(members[0].value, fact.value));
+    if (home === undefined) classes.push([fact]);
+    else home.push(fact);
+    return classes;
+  }, []);
+
+/** 一つの組の中で値が二通りなら、最初の値と違う事実。 */
+const conflictsInClass = (facts: readonly ScopedFact[]): FactConflict[] => {
+  const [first, ...rest] = facts;
+  if (first === undefined) return [];
+  if (distinctValues(facts.map((fact) => fact.value)).length !== MAX_DISTINCT) return [];
+  return rest.filter((fact) => !sameValue(first.value, fact.value)).map((fact) => ({ fact, other: first.value }));
+};
+
+/** 記録の欄（繰り返す名前）は比べない。 */
+const conflictsIn = (facts: readonly ScopedFact[]): FactConflict[] =>
+  facts.some((fact) => fact.record) ? [] : comparableClasses(facts).flatMap(conflictsInClass);
+
+/** 同じ範囲の中で、同じ名前に二通りの値。 */
+export const scopeConflicts = (facts: readonly ScopedFact[]): FactConflict[] => groupBy(facts, (fact) => `${fact.scope}\u0000${fact.key}`).flatMap(conflictsIn);
+
+const isSummary = (fact: ScopedFact): boolean => fact.part !== "body";
+
+/** 要約か冒頭の値が、本文で揃って書かれた値と違う。 */
+const summaryConflict = (fact: ScopedFact, body: readonly ScopedFact[]): FactConflict[] => {
+  const values = distinctValues(body.filter((other) => other.key === fact.key && comparable(fact.value, other.value)).map((other) => other.value));
+  const only = values.length === 1 ? values[0] : undefined;
+  return only === undefined || sameValue(fact.value, only) ? [] : [{ fact, other: only }];
+};
+
+export const summaryConflicts = (facts: readonly ScopedFact[]): FactConflict[] => {
+  const body = facts.filter((fact) => !isSummary(fact) && !fact.record);
+  return facts.filter(isSummary).flatMap((fact) => summaryConflict(fact, body));
+};

package/src/facts/fact-scope.ts

@@ -0,0 +1,141 @@
+import type { StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { lineNumberAt, linesOf, type Line } from "../structure/lines.ts";
+import type { Fact } from "./labelled-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 事実の居場所。同じ名前でも、違う見出しの下、違う親の項目の下、太字だけの行や「第2回：」のような小見出しの行の後ろは、
+ * 別の催しや別の場合の値として比べない。scope が同じ事実どうしだけを比べる。
+ * part は冒頭（最初の見出しより前）、要約の節（概要、Summary）、本文のどれか。
+ */
+export type FactPart = "opening" | "summary" | "body";
+
+/** record: 同じ範囲で、行の頭に何度も書かれた名前。催しや論文ごとの記録の欄で、値が違っても食い違いではない。 */
+export type ScopedFact = Fact & { readonly scope: string; readonly part: FactPart; readonly record: boolean };
+
+const CONTAINERS: ReadonlySet<string> = new Set(["section", "chapter", "article"]);
+
+const LIST_ITEM = /^([ \t]*)(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+/** 小見出しの代わりの行: 太字だけの行（項目でもよい）、コロンで終わる短い行。 */
+const BOLD_LINE = /^[ \t]*(?:[-*+][ \t]+)?(?:\*\*|__)[^*_]+(?:\*\*|__)[:：]?[ \t]*$/u;
+const COLON_LINE = /^[^|]{1,40}[:：][ \t]*$/u;
+
+const covers = (node: StructureNode, offset: number): boolean => node.span.start <= offset && offset < node.span.end;
+
+const containersAt = (nodes: readonly StructureNode[], offset: number): StructureNode[] => nodes.filter((node) => covers(node, offset));
+
+const INDENT = /^[ \t]*/u;
+
+const indentOf = (line: Line | undefined): number => INDENT.exec(line?.text ?? "")?.[0].length ?? 0;
+
+/** 字下げの無い地の文の行。そこより上の項目は、もう別の並び。 */
+const leavesList = (line: Line): boolean => line.text.trim() !== "" && indentOf(line) === 0 && !LIST_ITEM.test(line.text);
+
+/**
+ * 親の項目: 自分より浅い字下げで、上にある一番近い項目の行。項目の下に字下げして続けた行（項目の続き）も、その項目を親とする。
+ * 字下げの無い行には無い。
+ */
+const parentItem = (lines: readonly Line[], index: number): number => {
+  const indent = indentOf(lines[index]);
+  if (indent === 0) return -1;
+  for (let at = index - 1; at >= 0; at -= 1) {
+    const line = lines[at];
+    if (line === undefined || leavesList(line)) return -1;
+    if (LIST_ITEM.test(line.text) && indentOf(line) < indent) return at;
+  }
+  return -1;
+};
+
+const MAX_HEAD_LABEL = 24;
+const HEAD_MARK = /^[ \t>]*(?:[-*+][ \t]+)?/u;
+/** 同じ範囲で、行の頭にこれだけ書かれた名前は、繰り返す記録の欄（一覧の Title:、Comments:）。 */
+const RECORD_REPEATS = 3;
+
+/** 行の頭の「名前：」の名前。比べる名前と同じ書き方に揃える。 */
+const headLabelOf = (line: Line): string | undefined => {
+  const text = line.text.replace(HEAD_MARK, "");
+  const colon = text.search(/[:：|]/u);
+  if (colon <= 0 || text.charAt(colon) === "|") return undefined;
+  const label = withoutEdgeMarks(text.slice(0, colon));
+  return label === "" || label.length > MAX_HEAD_LABEL ? undefined : label.normalize("NFKC").toLowerCase();
+};
+
+const isBreaker = (line: Line): boolean => BOLD_LINE.test(line.text) || (!LIST_ITEM.test(line.text) && COLON_LINE.test(line.text));
+
+/** 行ごとに、それより前にある小見出しの代わりの行の数。節の始まりから事実の行までの数は、二つの差になる。 */
+const breakerCounts = (lines: readonly Line[]): number[] =>
+  lines.reduce<number[]>(
+    (counts, line, index) => {
+      counts.push((counts[index] ?? 0) + (isBreaker(line) ? 1 : 0));
+      return counts;
+    },
+    [0],
+  );
+
+const lineIndexAt = (lines: readonly Line[], offset: number): number => (lineNumberAt(lines, offset) ?? 1) - 1;
+
+const isSummaryHeading = (node: StructureNode, summaryWords: readonly string[]): boolean => {
+  const heading = String(node.attrs["heading"] ?? "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/^[\d.\s]+/u, "")
+    .trim();
+  return summaryWords.some((word) => heading === word.toLowerCase());
+};
+
+const TOP_LEVEL_HEADING = /^h\d+$/u;
+
+/** 冒頭: 文書の頭か、表題の見出しの直下で、最初の小見出しより前。 */
+const isOpening = (innermost: StructureNode | undefined, tree: StructureNode, offset: number): boolean => {
+  const owner = innermost ?? tree;
+  if (owner !== tree && !TOP_LEVEL_HEADING.test(owner.address)) return false;
+  const firstChild = owner.children.find((child) => CONTAINERS.has(child.kind));
+  return firstChild === undefined ? owner === tree : offset < firstChild.span.start;
+};
+
+const partOf = (around: readonly StructureNode[], tree: StructureNode, offset: number, summaryWords: readonly string[]): FactPart => {
+  if (around.some((node) => node.kind === "section" && isSummaryHeading(node, summaryWords))) return "summary";
+  return isOpening(around.at(-1), tree, offset) ? "opening" : "body";
+};
+
+/** 名前ごとに、頭にその名前を書いた行の番号。 */
+const headLines = (lines: readonly Line[]): ReadonlyMap<string, readonly number[]> => {
+  const found = new Map<string, number[]>();
+  lines.forEach((line, index) => {
+    const head = headLabelOf(line);
+    if (head === undefined) return;
+    const indexes = found.get(head);
+    if (indexes === undefined) found.set(head, [index]);
+    else indexes.push(index);
+  });
+  return found;
+};
+
+/** 範囲の行のうち、頭にその名前を書いた行の数。 */
+const headCount = (heads: ReadonlyMap<string, readonly number[]>, from: number, to: number, key: string): number =>
+  (heads.get(key) ?? []).filter((index) => index >= from && index < to).length;
+
+type Lines = { readonly lines: readonly Line[]; readonly breakers: readonly number[]; readonly heads: ReadonlyMap<string, readonly number[]> };
+
+const scopeOf = (fact: Fact, innermost: StructureNode | undefined, at: Lines): { scope: string; record: boolean } => {
+  const index = lineIndexAt(at.lines, fact.value.start);
+  const from = innermost === undefined ? 0 : lineIndexAt(at.lines, innermost.span.start);
+  const to = innermost === undefined ? at.lines.length : lineIndexAt(at.lines, innermost.span.end - 1) + 1;
+  const scope = [innermost?.address ?? "doc", (at.breakers[index] ?? 0) - (at.breakers[from] ?? 0), parentItem(at.lines, index)].join("#");
+  return { scope, record: headCount(at.heads, from, to, fact.key) >= RECORD_REPEATS };
+};
+
+/** 事実ごとに、比べてよい範囲と、文書のどの部分かを付ける。 */
+export const scopedFacts = (facts: readonly Fact[], tree: StructureNode, source: string, summaryWords: readonly string[]): ScopedFact[] => {
+  if (facts.length === 0) return [];
+  const nodes = inDocumentOrder(tree).filter((node) => CONTAINERS.has(node.kind));
+  const lines = linesOf(source);
+  const at: Lines = { lines, breakers: breakerCounts(lines), heads: headLines(lines) };
+  return facts
+    .toSorted((left, right) => left.value.start - right.value.start)
+    .map((fact) => {
+      const around = containersAt(nodes, fact.value.start);
+      return { ...fact, ...scopeOf(fact, around.at(-1), at), part: partOf(around, tree, fact.value.start, summaryWords) };
+    });
+};

package/src/facts/fact-values.ts

@@ -0,0 +1,110 @@
+import type { Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { overlapsAny, spanIndex, type SpanIndex } from "../compare/spans.ts";
+
+/**
+ * 値として読むもの。木の数量と日付（`chaff compare` と同じ読み）と、品詞の読める言語では固有名詞。
+ * key は値の正体で、書き方が違っても同じ値なら同じ（3,000円と3000円、10月5日と10/5）。
+ */
+export type ValueKind = "quantity" | "date" | "name";
+
+export type FactValue = Span & { readonly kind: ValueKind; readonly key: string; readonly unit: string };
+
+const attr = (node: StructureNode, name: string): string => String(node.attrs[name] ?? "");
+
+/** 数の前に書いた単位（$300、$ 300）があれば、その始まり。木の数量は数から始まる。 */
+const startWithUnitBefore = (source: string, start: number, unit: string): number => {
+  if (unit === "") return start;
+  const gap = source[start - 1] === " " ? 1 : 0;
+  const from = start - gap - unit.length;
+  return from >= 0 && source.slice(from, start - gap) === unit ? from : start;
+};
+
+/** 数のすぐ後ろに書いた単位（25%の%）。木の数量は単位の前で終わることがある。 */
+const endWithUnitAfter = (source: string, end: number, unit: string): number => (unit !== "" && source.startsWith(unit, end) ? end + unit.length : end);
+
+const nodeValue = (node: StructureNode, source: string): FactValue[] => {
+  if (node.kind === "date") return [{ start: node.span.start, end: node.span.end, kind: "date", key: attr(node, "value"), unit: "" }];
+  if (node.kind !== "quantity") return [];
+  const unit = attr(node, "unit");
+  return [
+    {
+      start: startWithUnitBefore(source, node.span.start, unit),
+      end: endWithUnitAfter(source, node.span.end, unit),
+      kind: "quantity",
+      key: attr(node, "value"),
+      unit: unit.normalize("NFKC"),
+    },
+  ];
+};
+
+/**
+ * 単位を書かない数（「Seats: 40」）。前後が字や数や時刻の : でないもの。1.2.3 のような版の番号は数にしない。
+ * 単位の無い数は、単位の無い数とだけ比べる。
+ */
+const BARE_NUMBER = /(?<![\p{L}\p{N}.,:/-])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?(?![\p{L}\p{N}%:/,，-]|[.．][0-9０-９])/gu;
+
+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 [];
+    const key = String(Number(match[0].normalize("NFKC").replace(/,/gu, "")));
+    return [{ ...span, kind: "quantity", key, unit: "" }];
+  });
+
+/** 木の数量と日付、それと重ならない固有名詞と、単位を書かない数。文書の中の順に並べる。 */
+export const factValues = (tree: StructureNode, source: string, names: readonly Span[]): FactValue[] => {
+  const tagged = inDocumentOrder(tree).flatMap((node) => nodeValue(node, source));
+  const taken = spanIndex(tagged);
+  const named = names
+    .filter((name) => !overlapsAny(taken, name))
+    .map((name): FactValue => ({ start: name.start, end: name.end, kind: "name", key: source.slice(name.start, name.end).normalize("NFKC"), unit: "" }));
+  const bare = bareValues(source, spanIndex([...tagged, ...named]));
+  return [...tagged, ...named, ...bare].toSorted((left, right) => left.start - right.start);
+};
+
+/** 日付の書き方の細かさ。年月日、年月、月日。違う細かさどうしは、重なる部分だけを比べる。 */
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+const YEAR_MONTH = /^\d{4}-\d{2}$/u;
+const MONTH_DAY = /^\d{2}-\d{2}$/u;
+
+type Precision = "full" | "year-month" | "month-day" | "other";
+
+const precisionOf = (key: string): Precision => {
+  if (FULL_DATE.test(key)) return "full";
+  if (YEAR_MONTH.test(key)) return "year-month";
+  return MONTH_DAY.test(key) ? "month-day" : "other";
+};
+
+const YEAR_MONTH_LENGTH = 7;
+const MONTH_DAY_FROM = 5;
+
+/** 年月日の日付を、もう一方の細かさに揃える。揃えられなければ undefined。 */
+const narrowed = (full: string, other: string, precision: Precision): [string, string] | undefined => {
+  if (precision === "month-day") return [full.slice(MONTH_DAY_FROM), other];
+  return precision === "year-month" ? [full.slice(0, YEAR_MONTH_LENGTH), other] : undefined;
+};
+
+/** 二つの日付を比べられる形。比べられなければ undefined（年月と月日には重なる部分が無い）。 */
+const comparableDates = (left: string, right: string): [string, string] | undefined => {
+  const [a, b] = [precisionOf(left), precisionOf(right)];
+  if (a === b) return a === "other" && left !== right ? undefined : [left, right];
+  if (a === "full") return narrowed(left, right, b);
+  if (b !== "full") return undefined;
+  const pair = narrowed(right, left, a);
+  return pair === undefined ? undefined : [pair[1], pair[0]];
+};
+
+/** 同じ種類の値で、比べられるもの。数量は同じ単位どうし（単位の違いは別の 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;
+  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;
+  const pair = comparableDates(left.key, right.key);
+  return pair !== undefined && pair[0] === pair[1];
+};

package/src/facts/labelled-facts.ts

@@ -0,0 +1,131 @@
+import type { FactValue } from "./fact-values.ts";
+import { EDGE_MARKS, trimEndOf, withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 名前の付いた値（「締切：10月5日」「参加費は3,000円です」"Fee: $300" "The deadline is May 3."）と、
+ * 属性の言い回しに続く値（"headquartered in Austin"、「東京に本社を置く」）。
+ * 名前は文の頭から区切り（：、は、is）までで、値は区切りのすぐ後ろから文の切れ目まで。値の後ろに語が続けば（「3,000円から」
+ * 「$300 per person」）、条件の付いた値なので読まない。読点のあとから始まる名前（「大人は、」「For adults, the fee」）も、
+ * 前に条件があるので読まない。言語の知識（区切り、値の終わり、落とす冠詞）は言語パッケージの語彙表から取る。
+ */
+export type AttributePhrase = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type FactWords = {
+  /** 名前と値の区切り（：、は、is）。英字だけの区切りは、前が空白のときだけ。 */
+  readonly separators: readonly string[];
+  /** 値のすぐ後ろに来てよいもの（。、です、まで、.）。行の終わりと表の升の終わりはいつでもよい。 */
+  readonly valueEnds: readonly string[];
+  /** 名前の頭から落とす語（the, our）。 */
+  readonly determiners: readonly string[];
+  /** 名前にならない語（それ、it）。 */
+  readonly vague: readonly string[];
+  readonly attributes: readonly AttributePhrase[];
+};
+
+export type Fact = { readonly label: string; readonly key: string; readonly value: FactValue };
+
+const MAX_LABEL_LENGTH = 24;
+const MAX_LABEL_WORDS = 5;
+
+const MARKS_AFTER_VALUE = /^[*_]+/u;
+
+/** 文の切れ目。名前はこの後ろから始まる。表の升の区切りと、空白の前のピリオド（1. や文の終わり）も切れ目。 */
+const SENTENCE_BREAK = /[。！？!?|．]|\.(?=\s)/gu;
+const CLAUSE_COMMA = /[、，,]/u;
+const BLOCK_MARK = /^[ \t]*(?:#{1,6}[ \t]+|>[ \t]?)?/u;
+const ITEM_MARK = /^[-*+][ \t]+/u;
+const LETTER = /\p{L}/u;
+/** 名前に書かない記号。コードや属性（{style="…"}、"key"=）の中の値は、項目の値ではない。 */
+const CODE_MARK = /[{}<>=[\]"`]/u;
+const LATIN_WORD = /^[a-z ]+$/iu;
+
+const lineStartOf = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const lineEndOf = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+/** 区切りの前の名前の部分。英字の区切りは語の頭から（「this」の is は区切りではない）。 */
+const beforeSeparator = (head: string, separator: string): string | undefined => {
+  if (!head.toLowerCase().endsWith(separator.toLowerCase())) return undefined;
+  const rest = head.slice(0, head.length - separator.length);
+  if (LATIN_WORD.test(separator) && !/\s$/u.test(rest)) return undefined;
+  return rest;
+};
+
+/** 最後の文の切れ目より後ろ。 */
+const afterLastBreak = (text: string): string => {
+  const breaks = [...text.matchAll(SENTENCE_BREAK)];
+  const last = breaks.at(-1);
+  return last === undefined ? text : text.slice(last.index + last[0].length);
+};
+
+const wordsOf = (text: string): string[] => text.split(/\s+/u).filter((word) => word !== "");
+
+/** 名前を一つの書き方に。全角と半角、大文字と小文字、空白の数を揃え、頭の冠詞を落とす。 */
+const keyOf = (label: string, words: FactWords): string => {
+  const [first, ...rest] = wordsOf(label.normalize("NFKC").toLowerCase());
+  const determiners = new Set(words.determiners.map((word) => word.toLowerCase()));
+  return (first !== undefined && determiners.has(first) ? rest : [first ?? "", ...rest]).join(" ");
+};
+
+const containsSeparator = (label: string, words: FactWords): boolean =>
+  words.separators.some((separator) =>
+    LATIN_WORD.test(separator) ? wordsOf(label.toLowerCase()).includes(separator.toLowerCase()) : label.includes(separator),
+  );
+
+/** 名前として使える書き方か。短く、字を含み、区切りを含まず、指すだけの語（それ、it）でない。 */
+const isLabel = (label: string, key: string, words: FactWords): boolean =>
+  label.length > 0 &&
+  label.length <= MAX_LABEL_LENGTH &&
+  wordsOf(label).length <= MAX_LABEL_WORDS &&
+  LETTER.test(key) &&
+  !CODE_MARK.test(label) &&
+  !containsSeparator(label, words) &&
+  !words.vague.some((word) => word.toLowerCase() === key);
+
+/** 値の後ろが文の切れ目か。行の終わり、表の升の終わり、語彙表の終わりの語。 */
+const endsAfter = (source: string, value: FactValue, words: FactWords): boolean => {
+  const after = source.slice(value.end, lineEndOf(source, value.end)).replace(MARKS_AFTER_VALUE, "");
+  if (after.trim() === "" || after.trimStart().startsWith("|")) return true;
+  return words.valueEnds.some((end) => after.startsWith(end));
+};
+
+const labelledFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
+  const head = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS);
+  for (const separator of words.separators) {
+    const before = beforeSeparator(head, separator);
+    if (before === undefined) continue;
+    const clause = afterLastBreak(before).replace(BLOCK_MARK, "").replace(ITEM_MARK, "");
+    if (CLAUSE_COMMA.test(clause)) return undefined;
+    const label = withoutEdgeMarks(clause);
+    const key = keyOf(label, words);
+    return isLabel(label, key, words) ? { label, key, value } : undefined;
+  }
+  return undefined;
+};
+
+/** 属性の言い回しのすぐ前か後ろの値。名前は言い回しそのもの。 */
+const attributeFact = (source: string, value: FactValue, words: FactWords): Fact | undefined => {
+  const head = trimEndOf(source.slice(lineStartOf(source, value.start), value.start), EDGE_MARKS).toLowerCase();
+  const tail = source
+    .slice(value.end, lineEndOf(source, value.end))
+    .replace(/^[ \t]+/u, "")
+    .toLowerCase();
+  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;
+  return { label: found.pattern, key: keyOf(found.pattern, words), value };
+};
+
+/** 文に書いた名前付きの値。値ごとに、属性の言い回しか、区切りの前の名前を探す。 */
+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);
+    return fact === undefined ? [] : [fact];
+  });

package/src/facts/measures.ts

@@ -0,0 +1,54 @@
+import type { FactValue } from "./fact-values.ts";
+
+/**
+ * 単位の付いた量（5 km、3000 m、1.5時間、2 GB）。単位は言語パッケージの語彙表から取り、量の種類（長さ、重さ…）と、基準の単位への
+ * 倍率を持つ。倍率が二つある単位（1 GB は 10^9 か 2^30 バイト）は、どちらで数えても合えば合う。
+ */
+export type MeasureUnit = { readonly pattern: string; readonly dimension: string; readonly factors: readonly number[] };
+
+export type Measured = FactValue & { readonly dimension: string; readonly factors: readonly number[]; readonly amount: number };
+
+/** 前に英字や数が続く数（v2、A4、1.2.3 の 2）は量ではない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
+const NUMBER = /(?<![\p{Script=Latin}\p{N}.,])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+
+/**
+ * 数のすぐ後ろ（空白一つまで）の単位。長い単位から試す（「5分間」を 分 で切らない、min を m にしない）。
+ * 単位の後ろに語が続く（5 miners）ものは、名前付きの値の終わり（fact-value-end）で落ちるので、ここでは見ない。
+ */
+const unitAfter = (source: string, end: number, units: readonly MeasureUnit[]): { unit: MeasureUnit; end: number } | undefined => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + 16);
+  const unit = units.find((candidate) => rest.startsWith(candidate.pattern));
+  return unit === undefined ? undefined : { unit, end: end + gap + unit.pattern.length };
+};
+
+/** 文書の中の、単位の付いた量。 */
+export const measuredValues = (source: string, units: readonly MeasureUnit[]): Measured[] => {
+  const longestFirst = units.toSorted((left, right) => right.pattern.length - left.pattern.length);
+  return [...source.matchAll(NUMBER)].flatMap((match): Measured[] => {
+    const found = unitAfter(source, match.index + match[0].length, longestFirst);
+    if (found === undefined) return [];
+    const amount = Number(match[0].normalize("NFKC").replace(/,/gu, ""));
+    return [
+      {
+        start: match.index,
+        end: found.end,
+        kind: "quantity",
+        key: String(amount),
+        unit: found.unit.pattern,
+        dimension: found.unit.dimension,
+        factors: found.unit.factors,
+        amount,
+      },
+    ];
+  });
+};
+
+/** 二つの量が同じ量か。倍率のどの組み合わせかで、基準の単位に直した値の差が大きいほうの tolerance 以内なら同じ。 */
+export const sameMeasure = (left: Measured, right: Measured, tolerance: number): boolean =>
+  left.factors.some((a) =>
+    right.factors.some((b) => {
+      const [x, y] = [left.amount * a, right.amount * b];
+      return Math.abs(x - y) <= Math.max(Math.abs(x), Math.abs(y)) * tolerance;
+    }),
+  );