chaffjs 0.19.0 → 0.21.0

package/src/extension/plugin-load.ts

@@ -1,3 +1,4 @@
+import { existsSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { CONFIG_FILE, type Config } from "../config/load.ts";
@@ -7,6 +8,7 @@ import { importDefault } from "./import-default.ts";
 import { staysInside } from "./real-path.ts";
 import { isPluginPath, pluginNameOfPackage } from "./plugin-name.ts";
 import { parsePlugin, type ParsedPlugin, type PluginOrigin, type PluginProblem } from "./plugin-parse.ts";
+import { PACK_MANIFEST, packManifestOf, packageNameOf, readPack } from "./pack-read.ts";
 
 // The plugins chaff.yaml lists under plugins:, found and loaded. A package is found from the folder chaff.yaml is in,
 // as Node finds it (node_modules); a path is the project's own plugin and, like a module rule, may not leave that
@@ -14,7 +16,8 @@ import { parsePlugin, type ParsedPlugin, type PluginOrigin, type PluginProblem }
 
 export type LoadedPlugins = { readonly plugins: readonly ParsedPlugin[]; readonly problems: readonly PluginProblem[] };
 
-type Located = { readonly origin: PluginOrigin } | { readonly problem: PluginProblem };
+/** pack: the folder of a rule pack (YAML only), which is read rather than imported. */
+type Located = { readonly origin: PluginOrigin; readonly pack?: string } | { readonly problem: PluginProblem };
 
 const problemOf = (kind: Exclude<PluginProblem["kind"], "rule">, plugin: string, detail = ""): { problem: PluginProblem } => ({
   problem: { kind, plugin, detail },
@@ -29,24 +32,61 @@ const resolveFrom = (baseDir: string, specifier: string): string | undefined =>
   }
 };
 
+const isFolder = (path: string): boolean => existsSync(path) && statSync(path).isDirectory();
+
+/** A folder that is a rule pack: it has a manifest. A folder that is a code plugin is imported as Node imports it. */
+const isPack = (dir: string): boolean => packManifestOf(dir) !== undefined;
+
+/** The folder Node would find package name in from the folder chaff.yaml is in, whatever the package exports. */
+const packageFolder = (baseDir: string, name: string): string | undefined =>
+  (createRequire(join(baseDir, CONFIG_FILE)).resolve.paths(name) ?? [])
+    .map((nodeModules) => join(nodeModules, name))
+    .find((dir) => existsSync(join(dir, "package.json")));
+
+const packAt = (written: string, dir: string, expectedName: string | undefined): Located => ({
+  origin: { written, file: join(dir, PACK_MANIFEST), expectedName },
+  pack: dir,
+});
+
+/** A pack of the project's own takes its name from its package.json (chaff-plugin-foo is foo) when its manifest does not give one. */
+const localPackName = (dir: string): string | undefined => {
+  const name = packageNameOf(dir);
+  return name === undefined ? undefined : pluginNameOfPackage(name);
+};
+
+/** A plugin of the project's own, by its path: a pack folder, or a file (or folder) Node imports. Neither may leave the project. */
+const locatePath = (written: string, baseDir: string): Located => {
+  const path = modulePathOf(written, baseDir);
+  if ("refusal" in path) return problemOf("outside", written);
+  if (isFolder(path.file) && isPack(path.file))
+    return staysInside(written, path.file, baseDir) ? packAt(written, path.file, localPackName(path.file)) : problemOf("outside", written);
+  const file = resolveFrom(baseDir, path.file);
+  if (file === undefined) return problemOf("not-found", written);
+  return staysInside(written, file, baseDir) ? { origin: { written, file, expectedName: undefined } } : problemOf("outside", written);
+};
+
 const locate = (written: string, baseDir: string): Located => {
-  if (isPluginPath(written)) {
-    const path = modulePathOf(written, baseDir);
-    if ("refusal" in path) return problemOf("outside", written);
-    const file = resolveFrom(baseDir, path.file);
-    if (file === undefined) return problemOf("not-found", written);
-    return staysInside(written, file, baseDir) ? { origin: { written, file, expectedName: undefined } } : problemOf("outside", written);
-  }
+  if (isPluginPath(written)) return locatePath(written, baseDir);
   const expectedName = pluginNameOfPackage(written);
   if (expectedName === undefined) return problemOf("bad-specifier", written);
+  const folder = packageFolder(baseDir, written);
+  if (folder !== undefined && isPack(folder)) return packAt(written, folder, expectedName);
   const file = resolveFrom(baseDir, written);
   return file === undefined ? problemOf("not-found", written) : { origin: { written, file, expectedName } };
 };
 
+/** A rule pack read into what a code plugin's default export would be. Nothing in it runs. */
+const readPackAt = (dir: string, expectedName: string | undefined): { readonly exported: unknown } | { readonly message: string } => {
+  const manifest = packManifestOf(dir);
+  if (manifest !== undefined && "message" in manifest) return manifest;
+  const read = readPack(dir, manifest?.manifest ?? {}, expectedName);
+  return "message" in read ? read : { exported: read.value };
+};
+
 const loadPlugin = async (written: string, baseDir: string, useFor: readonly string[]): Promise<LoadedPlugins> => {
   const located = locate(written, baseDir);
   if ("problem" in located) return { plugins: [], problems: [located.problem] };
-  const imported = await importDefault(located.origin.file);
+  const imported = located.pack === undefined ? await importDefault(located.origin.file) : readPackAt(located.pack, located.origin.expectedName);
   if ("message" in imported) return { plugins: [], problems: [problemOf("import-failed", written, imported.message).problem] };
   const read = parsePlugin(imported.exported, located.origin, useFor);
   return { plugins: read.plugin === undefined ? [] : [read.plugin], problems: read.problems };

package/src/extension/plugin-parse.ts

@@ -6,6 +6,7 @@ import { styleOf, type StyleDefinition } from "../style-parse.ts";
 import type { UntrustedDetector } from "./module-detector.ts";
 import { describeValue } from "./returned-findings.ts";
 import { isPluginName } from "./plugin-name.ts";
+import { knownGenres } from "../known-genres.ts";
 
 // What a plugin package exports (api.ts PluginSpec), read into what chaff runs: its rules with ids under the plugin's
 // name, their detectors, its word lists and its house styles. A rule is read exactly like a rule in custom_rules, with
@@ -109,6 +110,7 @@ const rulesOf = (raw: unknown, context: RulesContext): Rules => {
   const parsed = parseCustomRules(Array.isArray(raw) ? raw.map((entry: unknown) => asCustomRule(entry, origin.file)) : raw, {
     builtIn: new Set(),
     useFor: context.useFor,
+    genres: knownGenres(),
     baseDir: dirname(origin.file),
   });
   const detectors = detectorsByWrittenId(Array.isArray(raw) ? raw : []);
@@ -134,14 +136,19 @@ const rulesOf = (raw: unknown, context: RulesContext): Rules => {
 const lexiconEntryOf = (value: unknown): LexiconEntry | undefined => {
   if (typeof value === "string") return value.trim() === "" ? undefined : { pattern: value.trim() };
   if (!isRecord(value) || typeof value["pattern"] !== "string" || value["pattern"].trim() === "") return undefined;
-  const insteadOf = value["instead_of"];
-  return { pattern: value["pattern"].trim(), ...(typeof insteadOf === "string" && insteadOf.trim() !== "" ? { instead_of: insteadOf.trim() } : {}) };
+  const [insteadOf, rewrite] = [value["instead_of"], value["rewrite"]];
+  return {
+    pattern: value["pattern"].trim(),
+    ...(typeof insteadOf === "string" && insteadOf.trim() !== "" ? { instead_of: insteadOf.trim() } : {}),
+    ...(typeof rewrite === "string" && rewrite.trim() !== "" ? { rewrite: rewrite.trim() } : {}),
+  };
 };
 
 const lexiconOf = (words: unknown): Lexicon | undefined => {
   const entries = Array.isArray(words) ? words.map(lexiconEntryOf) : [undefined];
   const readable = entries.flatMap((entry) => (entry === undefined ? [] : [entry]));
-  return readable.length === entries.length ? readable : undefined;
+  // An empty list would leave its rules running and finding nothing, which reads as a clean document.
+  return readable.length === entries.length && readable.length > 0 ? readable : undefined;
 };
 
 type ListInLanguage = { readonly language: string; readonly list: string; readonly lexicon: Lexicon };

package/src/facts/address-values.ts

@@ -0,0 +1,74 @@
+import type { Span } from "../plugin.ts";
+
+// Two kinds of value a docs site repeats from page to page, read by scanning rather than by a backtracking pattern:
+// an email address (help@example.com) and a version of three parts or more, or one written with v (2.4.1, v3).
+
+const LOCAL_CHAR = /[\p{L}\p{N}._%+-]/u;
+const DOMAIN_CHAR = /[\p{L}\p{N}.-]/u;
+const DOT = ".";
+
+/** The longest address there is (RFC 5321), so a scan from one @ never reads the whole document. */
+const MAX_ADDRESS = 254;
+
+/** Where the run of isPart characters that ends at from begins (UTF-16 units, like the offsets). */
+const extendLeft = (source: string, from: number, isPart: RegExp): number => {
+  const windowStart = Math.max(0, from - MAX_ADDRESS);
+  const stop = source
+    .slice(windowStart, from)
+    .split("")
+    .findLastIndex((char) => !isPart.test(char));
+  return windowStart + stop + 1;
+};
+
+/** Where the run of isPart characters that starts at from ends. */
+const extendRight = (source: string, from: number, isPart: RegExp): number => {
+  const stop = source
+    .slice(from, from + MAX_ADDRESS)
+    .split("")
+    .findIndex((char) => !isPart.test(char));
+  return stop === -1 ? Math.min(source.length, from + MAX_ADDRESS) : from + stop;
+};
+
+/** A sentence's full stop after an address or a version is not part of it. */
+const withoutTrailingDots = (text: string): string => text.slice(0, text.split("").findLastIndex((char) => char !== DOT) + 1);
+
+/** The address around one @: a local part, and the labels of the domain up to the first empty one, two or more. */
+const addressAt = (source: string, at: number): Span | undefined => {
+  const start = extendLeft(source, at, LOCAL_CHAR);
+  const written = source.slice(at + 1, extendRight(source, at + 1, DOMAIN_CHAR)).split(DOT);
+  const empty = written.indexOf("");
+  const labels = empty === -1 ? written : written.slice(0, empty);
+  if (start === at || labels.length < 2) return undefined;
+  return { start, end: at + 1 + labels.join(DOT).length };
+};
+
+/** The addresses in the text, left to right. An @ inside the address before it starts none. */
+export const emailSpans = (source: string): Span[] =>
+  [...source.matchAll(/@/gu)].reduce<Span[]>((found, match) => {
+    const span = addressAt(source, match.index);
+    const previous = found.at(-1);
+    return span === undefined || (previous !== undefined && span.start < previous.end) ? found : [...found, span];
+  }, []);
+
+/** A run of digits and dots, with a v before it or not, that starts a word. */
+const VERSION_RUN = /(?<![\p{L}\p{N}.])v?\d[\d.]*/gu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+const MIN_PARTS = 3;
+const MAX_PARTS = 4;
+const DIGITS = /^\d+$/u;
+
+/** A version: v and one part or more (v3, v2.1), or three or four parts without it (2.4.1). Not a run that a word continues. */
+const versionIn = (written: string, next: string): string | undefined => {
+  const run = withoutTrailingDots(written);
+  const prefixed = run.startsWith("v");
+  const parts = (prefixed ? run.slice(1) : run).split(DOT);
+  if (WORD_CHAR.test(next) && run === written) return undefined;
+  if (!parts.every((part) => DIGITS.test(part))) return undefined;
+  return prefixed || (parts.length >= MIN_PARTS && parts.length <= MAX_PARTS) ? run : undefined;
+};
+
+export const versionSpans = (source: string): Span[] =>
+  [...source.matchAll(VERSION_RUN)].flatMap((match) => {
+    const run = versionIn(match[0], source.charAt(match.index + match[0].length));
+    return run === undefined ? [] : [{ start: match.index, end: match.index + run.length }];
+  });

package/src/facts/cross-facts.ts

@@ -0,0 +1,54 @@
+import { comparable, sameValue, type FactValue } from "./fact-values.ts";
+import type { ScopedFact } from "./fact-scope.ts";
+import { tallyVotes, type Vote } from "../cross-votes.ts";
+
+// The same labelled fact given different values in different files of one run ("Monthly fee: $12" in one page, "$15" in
+// another). Pure: the facts come in already read from each file. Within a file, fact-conflict compares section by section.
+
+/** A file's labelled facts, by its path. */
+export type FileFacts = { readonly path: string; readonly facts: readonly ScopedFact[] };
+
+/** A file whose value for a label differs from the value most files give it: its first fact, and one file of the usual value. */
+export type FactOutOfStep = { readonly path: string; readonly fact: ScopedFact; readonly usual: Vote<ScopedFact>; readonly files: number };
+
+/** Two values the files can be said to agree or disagree on: comparable, and the same. */
+const sameFact = (left: ScopedFact, right: ScopedFact): boolean => sameValue(left.value, right.value);
+
+/**
+ * A file's vote for a label: its first fact, when every fact of the label in the file gives the same value. A file giving
+ * the label two values is either a list (a fee per plan) or a conflict within the file, which fact-conflict reports.
+ */
+const voteOf = (file: FileFacts, key: string): Vote<ScopedFact>[] => {
+  const facts = file.facts.filter((fact) => fact.key === key && !fact.record);
+  const [first] = facts;
+  if (first === undefined) return [];
+  return facts.every((fact) => comparable(first.value, fact.value) && sameFact(first, fact)) ? [{ path: file.path, value: first }] : [];
+};
+
+/** The votes split into groups whose values can be compared at all (one unit, overlapping date precision). */
+const comparableGroups = (votes: readonly Vote<ScopedFact>[]): Vote<ScopedFact>[][] =>
+  votes.reduce<Vote<ScopedFact>[][]>((groups, vote) => {
+    const home = groups.find((group) => group[0] !== undefined && comparable(group[0].value.value, vote.value.value));
+    if (home === undefined) groups.push([vote]);
+    else home.push(vote);
+    return groups;
+  }, []);
+
+/** Two values across the files, as with fact-conflict in one section: three or more is read as a list, and left alone. */
+const MAX_VALUES = 2;
+
+const outOfStep = (votes: readonly Vote<ScopedFact>[]): FactOutOfStep[] => {
+  const tally = tallyVotes(votes, sameFact);
+  const [usual] = tally?.usual ?? [];
+  if (tally === undefined || usual === undefined || tally.values !== MAX_VALUES) return [];
+  return tally.odd.map((vote) => ({ path: vote.path, fact: vote.value, usual, files: tally.usual.length }));
+};
+
+/** The files whose value for a label differs from the value most files of the run give it. */
+export const factsOutOfStep = (files: readonly FileFacts[]): FactOutOfStep[] => {
+  const keys = [...new Set(files.flatMap((file) => file.facts.map((fact) => fact.key)))];
+  return keys.flatMap((key) => comparableGroups(files.flatMap((file) => voteOf(file, key))).flatMap(outOfStep));
+};
+
+/** The value as written, for a message. */
+export const writtenValue = (source: string, value: FactValue): string => source.slice(value.start, value.end);

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