chaffjs 0.9.0 → 0.11.0

package/src/document.ts

@@ -5,8 +5,10 @@ import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
-import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
+import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
+import { pageFurniture, textOutline } from "./page-furniture.ts";
+import { tokenizedLexicons } from "./lexicon-tokens.ts";
 import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
@@ -263,12 +265,20 @@ export const buildDocument = (
   const root = parse(source);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
-  const blocks = collectMasks(root, source);
+  // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
+  const blocks = [...collectMasks(root, source), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
   const masked = [...blocks, ...emphasisSpans(root, source)];
   const prose = maskSpans(source, masked);
   const paragraphSpans = spansOfType(root, "paragraph");
   const listItems = spansOfType(root, "listItem");
   const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  const lexicons = {
+    ...adapter.lexicons,
+    "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
+    // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
+    "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
+  };
+  const tagged = sentences.some((sentence) => sentence.tokens !== undefined);
   const patterns = adapter.structure;
   // null は「作ったが構造を読めない言語だった」、undefined は「まだ作っていない」。
   const tree: { value: StructureNode | null | undefined } = { value: undefined };
@@ -283,19 +293,25 @@ export const buildDocument = (
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: {
-      ...adapter.lexicons,
-      "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
-      // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
-      "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
-    },
+    lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {
       tree.value ??=
         patterns === undefined
           ? null
-          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE, profile }, patterns);
+          : buildTree(
+              {
+                path,
+                source,
+                language: adapter.id,
+                // テキストの文書は、ページの飾りを覆って読む。フッターの「Section 9」を木の節にしない。
+                outline: isMarkdownPath(path) ? outlineOf(root, source) : textOutline(source),
+                markdown: isMarkdownPath(path),
+                profile,
+              },
+              patterns,
+            );
       return tree.value ?? undefined;
     },
     profile,

package/src/lexicon-tokens.ts

@@ -0,0 +1,28 @@
+import type { LanguageAdapter, Lexicon, LexiconEntry } from "./plugin.ts";
+
+/** adapter の語彙表は adapter ごとに一度だけ分ける。チームの語彙表は文書ごとに作られるので、この表に残らない。 */
+const split = new WeakMap<LanguageAdapter, WeakMap<Lexicon, Lexicon>>();
+
+const splitBy = (adapter: LanguageAdapter): WeakMap<Lexicon, Lexicon> => {
+  const known = split.get(adapter) ?? new WeakMap<Lexicon, Lexicon>();
+  split.set(adapter, known);
+  return known;
+};
+
+const tokenized = (entry: LexiconEntry, adapter: LanguageAdapter): LexiconEntry => {
+  const tokens = adapter.segment(entry.pattern).sentences.flatMap((sentence) => sentence.tokens ?? []);
+  return tokens.length === 0 ? entry : { ...entry, tokens };
+};
+
+const withTokens = (lexicon: Lexicon, adapter: LanguageAdapter): Lexicon => {
+  const cache = splitBy(adapter);
+  const known = cache.get(lexicon);
+  if (known !== undefined) return known;
+  const made = lexicon.map((entry) => tokenized(entry, adapter));
+  cache.set(lexicon, made);
+  return made;
+};
+
+/** 語彙表の語を、文と同じ解析器で語に分けておく。語彙表の検査が原形で照らせるように。品詞を読んでいない文書には何もしない。 */
+export const tokenizedLexicons = (lexicons: Readonly<Record<string, Lexicon>>, adapter: LanguageAdapter): Readonly<Record<string, Lexicon>> =>
+  Object.fromEntries(Object.entries(lexicons).map(([name, lexicon]) => [name, withTokens(lexicon, adapter)]));

package/src/page-furniture.ts

@@ -0,0 +1,45 @@
+import type { Span } from "./plugin.ts";
+import { NO_OUTLINE, type Outline } from "./structure/build.ts";
+
+/** 改ページから、飾りの行を探しにいく行数。飾りと改ページのあいだには空行が数行入る。 */
+const REACH = 3;
+
+type Line = { readonly start: number; readonly end: number; readonly text: string };
+
+const linesOf = (source: string): Line[] => {
+  const scan = { start: 0 };
+  return source.split("\n").map((text) => {
+    const line = { start: scan.start, end: scan.start + text.length, text };
+    scan.start = line.end + 1;
+    return line;
+  });
+};
+
+const isBlank = (line: Line | undefined): boolean => line !== undefined && line.text.trim() === "";
+
+/** 改ページだけの行。行の途中の \f は本文の一部（写し間違い）で、ページの区切りではない。 */
+const PAGE_BREAK = /^[ \t]*\f[ \t\r]*$/u;
+
+/** index から step の向きに、空行を飛ばして最初の空でない行。REACH 行を越えたら探さない。 */
+const nearestText = (lines: readonly Line[], index: number, step: number): Line | undefined => {
+  const candidates = Array.from({ length: REACH }, (_, offset) => lines[index + step * (offset + 1)]);
+  const skipped = candidates.findIndex((line) => !isBlank(line));
+  return skipped === -1 ? undefined : candidates[skipped];
+};
+
+/**
+ * 紙の版を写したテキスト（RFC など）の、ページのヘッダーとフッター。改ページ（\f）の直前と直後の、空でない 1 行ずつ。
+ * ページごとに同じ行が出るので、本文として読むと「同じ言い回しの繰り返し」や長い文になる。
+ */
+export const pageFurniture = (source: string): Span[] => {
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => {
+    if (!PAGE_BREAK.test(line.text)) return [];
+    return [nearestText(lines, index, -1), line, nearestText(lines, index, 1)].flatMap((found) =>
+      found === undefined ? [] : [{ start: found.start, end: found.end }],
+    );
+  });
+};
+
+/** テキストの文書の外形。見出しもコードも無く、ページの飾りだけを覆う。木を作る入口はどれもこれを使う。 */
+export const textOutline = (source: string): Outline => ({ ...NO_OUTLINE, opaque: pageFurniture(source) });

package/src/plugin.ts

@@ -36,7 +36,13 @@ export type LengthUnit = "char" | "word";
  * `instead_of` は「同じことを言う別の書きかた」。文体の一貫性を見る rule が使う。
  * 2 つの書きかたのどちらが正しいかは決めず、**1 つの文書で混ざっていないか**だけを見る。
  */
-export type LexiconEntry = { readonly pattern: string; readonly weight?: number | undefined; readonly instead_of?: string | undefined };
+export type LexiconEntry = {
+  readonly pattern: string;
+  readonly weight?: number | undefined;
+  readonly instead_of?: string | undefined;
+  /** pattern を adapter が語に分けたもの。品詞が読めるときだけ core が入れる。語彙表を書く側は書かない。 */
+  readonly tokens?: readonly Token[] | undefined;
+};
 
 export type Lexicon = readonly LexiconEntry[];
 
@@ -213,6 +219,11 @@ export type DocumentProfile = {
   readonly caption?: string | undefined;
   /** 前条・同項のように、書いた場所から番地が決まる参照の読み方。無ければ読まない。 */
   readonly relative?: RelativeVocabulary | undefined;
+  /**
+   * 番号を書かない単位（古い法令の第 2 項以降）。indent で始まる行を、inside の種類の単位の中の、depth の深さの次の単位にする。
+   * inside の単位の行に、番号の後ろの本文が続くときだけ。
+   */
+  readonly unnumbered?: { readonly indent: string; readonly inside: string; readonly depth: number } | undefined;
 };
 
 /**
@@ -239,9 +250,17 @@ export type RelativeVocabulary = {
   readonly notAfter: string | undefined;
   /**
    * 読み替え（「『前条』とあるのは『…』」）の括弧。中の前条・同項は読み替える先の文の言葉で、ここからは決められないので読まない。
-   * 閉じの直後に after、開きの直前に before のどれかがあるものだけ。
+   * 閉じの直後に after、開きの直前に before のどれかがあるものだけ。中の番地を名指しした参照は、document の名前の文書を指す。
    */
-  readonly substitution: { readonly open: string; readonly close: string; readonly after: readonly string[]; readonly before: readonly string[] } | undefined;
+  readonly substitution:
+    | {
+        readonly open: string;
+        readonly close: string;
+        readonly after: readonly string[];
+        readonly before: readonly string[];
+        readonly document: string | undefined;
+      }
+    | undefined;
   /** 条を書かずにこの単位で始まる番地（法令の「第一項」「第二号」）は、書いた場所を含むまとまりの中を指す。 */
   readonly inside: readonly string[];
   /**
@@ -330,6 +349,8 @@ export type RuleDefinition = {
   readonly where: string | undefined;
   /** adapter に要る capability。"pos" / "lemma"。満たさなければ動かさない。spec §16。 */
   readonly requires: readonly string[];
+  /** 使えるなら用意してほしい capability（"pos"）。requires と違い、満たせなくても動かす（品詞が無ければ文字だけで見る）。 */
+  readonly uses: readonly string[];
   /** 複合シグナル。ここに並べた rule のうち何本が出たかを見る。spec §20.2。 */
   readonly from: readonly string[];
   /** 動かす言語。未指定は全言語。「ですます調」のように言語に固有の rule が使う。 */

package/src/profile/parse.ts

@@ -41,7 +41,16 @@ const substitutionOf = (value: unknown): RelativeVocabulary["substitution"] => {
   if (!isRecord(value)) return undefined;
   const [open, close] = [text(value["open"]), text(value["close"])];
   const [after, before] = [strings(value["after"]), strings(value["before"])];
-  return open === undefined || close === undefined || after.length + before.length === 0 ? undefined : { open, close, after, before };
+  return open === undefined || close === undefined || after.length + before.length === 0
+    ? undefined
+    : { open, close, after, before, document: text(value["document"]) };
+};
+
+/** 字下げと、どの種類の中か、どの深さかのどれかが無ければ読まない。 */
+const unnumberedOf = (value: unknown): DocumentProfile["unnumbered"] => {
+  if (!isRecord(value)) return undefined;
+  const [indent, inside, depth] = [text(value["indent"]), text(value["inside"]), value["depth"]];
+  return indent === undefined || inside === undefined || !Number.isInteger(depth) || typeof depth !== "number" ? undefined : { indent, inside, depth };
 };
 
 /** 単位が一つも無ければ読まない。何を指すのか決められない。 */
@@ -78,7 +87,11 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
         const addressEnd = text(section["address_end"]);
         const caption = text(section["caption"]);
         const relative = relativeOf(section["relative"]);
-        return [language, { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative }];
+        const unnumbered = unnumberedOf(section["unnumbered"]);
+        return [
+          language,
+          { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative, unnumbered },
+        ];
       }),
   );
 

package/src/render/compact.ts

@@ -1,6 +1,18 @@
 import type { RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
+
+/** 「1 finding」「2 findings」。 */
+const counted = (count: number, noun: string): string => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+
+/**
+ * 最後の集計の行は、画面のほかの部分と同じく文書の言語で出す。行ごとの重さ（warning / error）は、grep や別の道具が読むので英語のまま。
+ */
+const TALLY: Texts<{ readonly findings: (n: number) => string; readonly notRun: (n: number) => string; readonly separator: string }> = {
+  ja: { findings: (n) => `指摘 ${String(n)} 件`, notRun: (n) => `動いていない rule ${String(n)} 件`, separator: "、" },
+  en: { findings: (n) => counted(n, "finding"), notRun: (n) => `${counted(n, "rule")} not run`, separator: ", " },
+};
 
 /** エンジニア向け。1 件 2 行。 */
 export const renderCompact = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
@@ -11,8 +23,9 @@ export const renderCompact = (header: string, result: RunResult, rules: readonly
     const at = `${finding.line}:${finding.column}`.padEnd(8);
     return [`  ${at}${finding.severity.padEnd(8)}${messageOf(rule, finding, language)}`, `          ${" ".repeat(8)}${finding.rule}`];
   });
-  const tail = [`${result.findings.length} findings`, result.skipped.length > 0 ? `${result.skipped.length} rules not run` : undefined].filter(
+  const text = TALLY[uiLanguageOf(language)];
+  const tail = [text.findings(result.findings.length), result.skipped.length > 0 ? text.notRun(result.skipped.length) : undefined].filter(
     (part) => part !== undefined,
   );
-  return ["", header, "", ...lines, "", tail.join(", "), ""].join("\n");
+  return ["", header, "", ...lines, "", tail.join(text.separator), ""].join("\n");
 };

package/src/rule-load.ts

@@ -102,6 +102,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
     requires: stringList(raw["requires"]) ?? [],
+    uses: stringList(raw["uses"]) ?? [],
     from: stringList(raw["from"]) ?? [],
     languages: stringList(raw["languages"]),
     use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],

package/src/run.ts

@@ -3,8 +3,11 @@ import { resolve } from "./levels.ts";
 import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
+import { joinWords } from "./detectors/word-list.ts";
 import { unreadStructure, type Unread } from "./structure/unread.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
+import { maskSpans } from "./mask.ts";
+import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
@@ -32,14 +35,27 @@ const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.lan
  * 構造の rule が動けない理由。木を作れない言語か、番号の行を読めなかった文書。
  * 読めなかった文書で「参照先が無い」が 0 件なのは、確かめた結果ではないので、読めなかったと言う。
  */
+/**
+ * 木を読む rule の要求。structure は番号の並びを読む（読めなかった文書では動かない）。dates と quantities は木の日付と数量だけを
+ * 読むので、番号を読めなかった文書でも動く。どちらも capability ではなく、adapter が木を作れるかで決まる。
+ */
+const TREE_NEEDS: ReadonlySet<string> = new Set(["structure", "dates", "quantities"]);
+const VALUE_NEEDS: readonly string[] = ["dates", "quantities"];
+
+const treeNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
+  if (rule.requires.includes("structure")) return treeProblem(doc);
+  return rule.requires.some((need) => VALUE_NEEDS.includes(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
+};
+
 const treeProblem = (doc: ProseDocument): string | undefined => {
   if (doc.structure === undefined) return reasonsFor(doc).noStructure(doc.language);
   const unread = unreadOf(doc);
   return unread === undefined ? undefined : reasonsFor(doc).unreadStructure(unread.clauses, unread.units);
 };
 
-/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はそのまま（.txt の字下げはコードではない）。 */
-const textTheTreeRead = (doc: ProseDocument): string => (isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : doc.source);
+/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はページの飾りだけを覆ったもの（.txt の字下げはコードではない）。 */
+const textTheTreeRead = (doc: ProseDocument): string =>
+  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source).opaque);
 
 const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
 
@@ -68,7 +84,7 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return reasonsFor(doc).otherLanguage(doc.language);
-  const missing = rule.requires.filter((need) => need !== "structure").find((need) => !has(doc.capabilities, need));
+  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
   if (missing !== undefined) return reasonsFor(doc).noCapability(missing);
   return undefined;
 };
@@ -91,7 +107,7 @@ export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, e
   pos: forGenre(rules, genre)
     .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental) !== "off")
     .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
-    .some((rule) => rule.requires.includes("pos") || rule.requires.includes("lemma")),
+    .some((rule) => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma")),
 });
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
@@ -107,7 +123,7 @@ const place = (starts: readonly number[], finding: Finding): Finding => {
  * 元の指摘は消さない。`padded-intro` のように単独でも正しい指摘が混ざっており、
  * まとめるために消すと本物の指摘が見えなくなる。
  */
-const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: number, starts: readonly number[]): Finding[] => {
+const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: number, starts: readonly number[], language: string): Finding[] => {
   const fired = rule.from.filter((id) => found.some((finding) => finding.rule === id));
   if (fired.length < limit) return [];
   const first = found.find((finding) => fired.includes(finding.rule));
@@ -118,7 +134,7 @@ const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: num
       line: 0,
       column: 0,
       quote: first?.quote ?? "",
-      values: { word: fired.join("、"), count: fired.length, limit, offset: first === undefined ? 0 : Number(first.values["offset"] ?? 0) },
+      values: { word: joinWords(fired, language), count: fired.length, limit, offset: first === undefined ? 0 : Number(first.values["offset"] ?? 0) },
     }),
   ];
 };
@@ -158,7 +174,7 @@ export const runRules = (
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
-      const noTree = rule.requires.includes("structure") ? treeProblem(doc) : undefined;
+      const noTree = treeNeed(rule, doc);
       if (noTree !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTree }] };
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
@@ -181,7 +197,7 @@ export const runRules = (
   );
   const composites = applicable
     .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts));
+    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts, doc.language));
   const all = [...outcome.findings, ...composites];
   return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
 };

package/src/sentence-shape.ts

@@ -37,4 +37,20 @@ const beforeTrailing = (sentence: Sentence): readonly Token[] => {
   return kept.length === 0 ? tokens : kept;
 };
 
+/** 閉じた引用。文がこれで終われば、文末は引用した文のもので、書き手の文末ではない。 */
+const CLOSING_QUOTES = ["」", "』", "\u201d"];
+
+/**
+ * 文末の語: 句読点・終助詞・添えた括弧を除いた後ろから、助動詞の連なりと、その前の述語一つ。
+ * 「測定しません」なら「し・ませ・ん」、「十分でしたか」なら「十分・でし・た」。文の途中の引用（「ご覧ください」という）は入らない。
+ * 引用で終わる文（画面には「確認します。」。）は、書き手の文末が無いので空。
+ */
+export const endingTokens = (sentence: Sentence): Token[] => {
+  const reversed = [...beforeTrailing(sentence)].reverse();
+  const last = reversed.findIndex((token) => !SKIP.has(token.pos));
+  if (last === -1 || reversed.slice(0, last).some((token) => CLOSING_QUOTES.some((quote) => token.surface.includes(quote)))) return [];
+  const head = reversed.findIndex((token, index) => index >= last && token.pos !== "AUX");
+  return reversed.slice(last, head === -1 ? reversed.length : head + 1).reverse();
+};
+
 export const lastContent = (sentence: Sentence): Token | undefined => [...beforeTrailing(sentence)].reverse().find((token) => !SKIP.has(token.pos));

package/src/structure/bare-numbers.ts

@@ -0,0 +1,78 @@
+import type { Line } from "./runs.ts";
+
+/** 単位を書かない数。単位は表の列の見出しにあるか、無い。木の数量は必ず単位を持つので、空の単位とは重ならない。 */
+export const NO_UNIT = "";
+
+export type BareNumber = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: typeof NO_UNIT };
+
+/**
+ * 表の升に数だけを書いたもの（1,205、12.5、-50、▲50、**1,205**）。前の印と強調は数に入れない。
+ * 0 で始まる番号（007）、区切りの崩れた 1,20、括弧の (50)、注の付いた 1,205a は数にしない。
+ */
+const BARE_NUMBER = /^(?:[1-9]\d{0,2}(?:,\d{3})+|[1-9]\d*|0)(?:\.\d+)?$/u;
+
+/** 数の前の空白、強調、負の印（-、▲）と、数の後ろの強調と空白。 */
+const BEFORE_NUMBER = /^[ \t]*[*_]*(?:[-−▲△][ \t]?)?/u;
+const AFTER_NUMBER = /^[*_]*\s*$/u;
+const DIGITS = /^[\d,.]*/u;
+
+/** 表の列の区切り。\| は列の中に書いた | なので数えない。 */
+export const CELL_SEPARATOR = /(?<!\\)\|/gu;
+
+type CellSpan = { readonly start: number; readonly end: number };
+
+const cellsOf = (source: string, line: Line): CellSpan[] => {
+  const text = source.slice(line.start, line.end);
+  const bounds = [-1, ...[...text.matchAll(CELL_SEPARATOR)].map((match) => match.index), text.length];
+  return bounds.slice(1).map((end, index) => ({ start: line.start + (bounds[index] ?? 0) + 1, end: line.start + end }));
+};
+
+type InColumn = BareNumber & { readonly column: number; readonly digits: string };
+
+const bareNumberIn = (source: string, cell: CellSpan, column: number): InColumn[] => {
+  const text = source.slice(cell.start, cell.end);
+  const before = BEFORE_NUMBER.exec(text)?.[0] ?? "";
+  const rest = text.slice(before.length);
+  const digits = DIGITS.exec(rest)?.[0] ?? "";
+  if (!BARE_NUMBER.test(digits) || !AFTER_NUMBER.test(rest.slice(digits.length))) return [];
+  const offset = cell.start + before.length;
+  return [{ offset, end: offset + digits.length, value: Number(digits.replace(/,/gu, "")), unit: NO_UNIT, column, digits }];
+};
+
+/** 表の見出し。最初の行の上の区切り行（|---|）の、さらに上の行。 */
+const headerAbove = (source: string, firstRow: Line | undefined): string => {
+  if (firstRow === undefined || firstRow.start < 2) return "";
+  const ruleStart = source.lastIndexOf("\n", firstRow.start - 2) + 1;
+  if (ruleStart < 2) return "";
+  return source.slice(source.lastIndexOf("\n", ruleStart - 2) + 1, ruleStart - 1);
+};
+
+/** 見出しに % のある列は率。 */
+const PERCENT = /[%％]/u;
+
+/** 同じ桁数で 4 桁以上の、区切りの無い整数だけの列は、年か番号（2024、1041）。 */
+const YEAR_OR_CODE = /^\d{4,}$/u;
+
+const isYearsOrCodes = (numbers: readonly InColumn[]): boolean =>
+  numbers.every((number) => YEAR_OR_CODE.test(number.digits) && number.digits.length === numbers[0]?.digits.length);
+
+/** 足してよい列か。見出しが率を言う列と、年や番号の列は足さない。 */
+const isAmountColumn = (header: string, numbers: readonly InColumn[], column: number): boolean =>
+  !PERCENT.test(header.split(CELL_SEPARATOR)[column] ?? "") && !isYearsOrCodes(numbers);
+
+/** 表の行の、数だけを書いた升。箇条書きの行は読まない。 */
+export const bareNumbersIn = (source: string, lines: readonly Line[]): BareNumber[] => {
+  const rows = lines.filter((line) => line.kind === "table");
+  const found = rows.flatMap((line) => cellsOf(source, line).flatMap((cell, column) => bareNumberIn(source, cell, column)));
+  const header = headerAbove(source, rows[0]);
+  const amountColumns = new Set(
+    [...new Set(found.map((number) => number.column))].filter((column) =>
+      isAmountColumn(
+        header,
+        found.filter((number) => number.column === column),
+        column,
+      ),
+    ),
+  );
+  return found.filter((number) => amountColumns.has(number.column)).map(({ offset, end, value, unit }) => ({ offset, end, value, unit }));
+};

package/src/structure/build.ts

@@ -1,12 +1,13 @@
 import type { Heading } from "../document.ts";
 import { atxHeadingText, headingText } from "../heading-text.ts";
 import { addressSpans } from "../address-chain.ts";
-import { relativeMentions } from "./relative-find.ts";
+import { relativeMentions, substitutedDocuments } from "./relative-find.ts";
 import { resolveRelative } from "./relative-resolve.ts";
 import { maskSpans } from "../mask.ts";
 import type { DocumentProfile, Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { dottedNumber } from "./universal.ts";
+import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -24,7 +25,7 @@ type Draft = {
 };
 
 /** 開いている節点。rank の大きいものほど内側。 */
-type Frame = { readonly draft: Draft; readonly rank: number; readonly numbered?: NumberedLine | undefined };
+type Frame = { readonly draft: Draft; readonly rank: number; readonly numbered?: NumberedLine | undefined; readonly bodyOnLine?: boolean };
 
 /**
  * 見出しは深さ 1〜6 を rank にする。番号のまとまりは必ず見出しの内側に入るので、
@@ -43,6 +44,7 @@ type State = {
   readonly profile: DocumentProfile | undefined;
   /** 見出しだけの行（文書の種類の caption）の行番号と、その言葉。すぐ次の行の条が見出しに使う。 */
   readonly captions: Map<number, string>;
+  readonly plainText: boolean;
 };
 
 const draftOf = (kind: StructureKind, address: string, line: Line, attrs: Readonly<Record<string, string | number>>): Draft => ({
@@ -96,7 +98,7 @@ const headingAddress = (state: State, depth: number): string => {
  * 見出しに書いた番号（「## 第3条」）は、見出しの深さで入れ子にする。本文の番号は見出しの内側に入る。
  * 見出しの深さを捨てると、「## 第3条」の下の「### 詳細」が条の外に出てしまう。
  */
-const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingDepth: number | undefined): void => {
+const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingDepth: number | undefined, bodyOnLine: boolean): void => {
   const attrs = { label: numbered.label, ...(numbered.heading === "" ? {} : { heading: numbered.heading }) };
   const rank = headingDepth ?? NUMBERED_RANK + numbered.depth;
   // 番地は、自分と同じか内側を閉じてから決める。閉じる前だと、同じ深さの前の条を親と取り違える。
@@ -108,7 +110,7 @@ const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingD
     ordinalTo: numbered.ordinalTo,
     numbering: numbered.numbering,
   };
-  open(state, { draft, rank, numbered });
+  open(state, { draft, rank, numbered, bodyOnLine });
 };
 
 const openSection = (state: State, line: Line, heading: Heading): void => {
@@ -130,7 +132,7 @@ type LeafFinder = (patterns: StructurePatterns, text: string, profile: DocumentP
 
 const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder }[] = [
   { kind: "definition", find: (patterns, text) => patterns.definitions(text) },
-  { kind: "reference", find: (patterns, text) => patterns.references(text) },
+  { kind: "reference", find: (patterns, text, profile) => substitutedDocuments(patterns.references(text), text, profile) },
   {
     kind: "reference",
     find: (patterns, text, profile) => {
@@ -144,8 +146,8 @@ const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder
 ];
 
 /** 言語を問わない通し番号。後ろが単位なら数量なので番号にしない。 */
-const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext): NumberedLine | undefined => {
-  const dotted = dottedNumber(text, context);
+const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
+  const dotted = dottedNumber(text, context, plainText);
   return dotted !== undefined && patterns.countedAfter?.(dotted.number, dotted.rest) === true ? undefined : dotted;
 };
 
@@ -230,6 +232,8 @@ export type StructureInput = {
   readonly source: string;
   readonly language: string;
   readonly outline: Outline;
+  /** Markdown か、テキストか。テキストの仕様書だけの書き方（「5.  Security Considerations」）がある。 */
+  readonly markdown: boolean;
   readonly profile?: DocumentProfile | undefined;
 };
 
@@ -265,6 +269,18 @@ const captionOf = (profile: DocumentProfile | undefined, text: string): string |
   return words === "" ? undefined : words;
 };
 
+const openUnits = (state: State): OpenUnit[] =>
+  state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [{ numbered: frame.numbered, bodyOnLine: frame.bodyOnLine === true }]));
+
+/** 言語の番号の読み方、文書の種類の番号を書かない単位、言語を問わない通し番号の順に読む。 */
+const numberedLine = (state: State, patterns: StructurePatterns, text: string, context: NumberingContext): NumberedLine | undefined =>
+  patterns.numbered(text, context) ??
+  unnumberedUnit(text, openUnits(state), state.profile?.unnumbered) ??
+  universalNumber(patterns, text, context, state.plainText);
+
+/** 番号の後ろが見出しでなく本文か。前の行から見出しが付く前の、行そのもので決める。 */
+const carriesBody = (found: NumberedLine | undefined): boolean => found !== undefined && found.heading === "" && found.rest !== "";
+
 /** 見出しの無い条のすぐ前の行が見出しだけの行なら、それを条の見出しにする。 */
 const withCaption = (state: State, line: Line, numbered: NumberedLine | undefined): NumberedLine | undefined => {
   const caption = numbered?.kind === "article" && numbered.heading === "" ? state.captions.get(line.number - 1) : undefined;
@@ -275,12 +291,13 @@ const readLine = (state: State, patterns: StructurePatterns, line: Line, heading
   const text = heading === undefined ? line.text : headingLineText(line.text);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
-  const numbered = withCaption(state, line, patterns.numbered(text, context) ?? universalNumber(patterns, text, context));
+  const found = numberedLine(state, patterns, text, context);
+  const numbered = withCaption(state, line, found);
   const caption = numbered === undefined && heading === undefined ? captionOf(state.profile, text) : undefined;
   if (caption !== undefined) state.captions.set(line.number, caption);
   // 番号付きの見出しも見出しの通し番号を進める。進めないと、その下の「### 詳細」が前の見出しの番地を名乗る。
   if (numbered !== undefined && heading !== undefined) headingAddress(state, heading.depth);
-  if (numbered !== undefined) openNumbered(state, line, numbered, heading?.depth);
+  if (numbered !== undefined) openNumbered(state, line, numbered, heading?.depth, carriesBody(found));
   else if (heading !== undefined) openSection(state, line, heading);
   extend(state, line.start + line.text.length);
   // 番号付きの行は番号の後ろだけを読む。「第3条（支払）」の「第3条」を自分への参照として拾わない。
@@ -309,6 +326,7 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
     widerScopes: new Map(),
     profile: input.profile,
     captions: new Map(),
+    plainText: !input.markdown,
   };
   lines.forEach((line) => {
     if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number));

package/src/structure/date-order.ts

@@ -0,0 +1,44 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+
+/**
+ * 日程として並べた日付の順番。箇条書きの続いた項目か、表の続いた行で、日付をちょうど一つ持つものを並びとして読む。
+ * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩だけを言う。新しい順に並べた履歴は正しい並び。
+ * 向きが決まらない並び（上がりと下がりが同じ数）は何も言わない。逆らう一歩を言えるのは、日付が 4 つ以上の並びだけになる。
+ */
+export type DatedPoint = { readonly offset: number; readonly value: string };
+
+/** 並びとして比べられる日付の書き方。年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
+const PRECISIONS = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u, /^\d{2}-\d{2}$/u];
+
+/** 行ごとの日付。ちょうど一つの行だけを並びに入れる。二つある行（期間）はどちらを並べたのか決められない。 */
+const datedLines = (run: readonly Line[], points: readonly DatedPoint[]): DatedPoint[] =>
+  run.flatMap((line) => {
+    const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
+    return inside.length === 1 && inside[0] !== undefined ? [inside[0]] : [];
+  });
+
+const samePrecision = (dated: readonly DatedPoint[]): boolean => PRECISIONS.some((pattern) => dated.every((point) => pattern.test(point.value)));
+
+/** 上がりが多ければ 1、下がりが多ければ -1、同じ数なら 0（向きを決めない）。 */
+const majorityOf = (up: number, down: number): number => Math.sign(up - down);
+
+/** 多いほうの向きに逆らう一歩。後ろの項目の日付を指す。 */
+const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
+  const steps = dated
+    .slice(1)
+    .map((point, index) => ({ point, previous: dated[index], sign: Math.sign(point.value.localeCompare(dated[index]?.value ?? "")) }));
+  const up = steps.filter((step) => step.sign > 0).length;
+  const down = steps.filter((step) => step.sign < 0).length;
+  const majority = majorityOf(up, down);
+  if (majority === 0) return [];
+  return steps
+    .filter((step) => step.sign === -majority)
+    .map((step) => ({ offset: step.point.offset, values: { date: step.point.value, previous: step.previous?.value ?? "" } }));
+};
+
+export const dateOrderBreaks = (source: string, points: readonly DatedPoint[]): StructureIssue[] =>
+  runsOf(source).flatMap((run) => {
+    const dated = datedLines(run, points);
+    return samePrecision(dated) ? againstMajority(dated) : [];
+  });