chaffjs 0.17.0 → 0.19.0

package/src/structure/of.ts

@@ -1,7 +1,8 @@
 import { markdownOutline } from "../document.ts";
-import type { DocumentProfile, StructureNode, StructurePatterns } from "../plugin.ts";
-import { buildTree } from "./build.ts";
+import type { DocumentProfile, Lexicon, StructureNode, StructurePatterns } from "../plugin.ts";
+import { buildTree, type Outline } from "./build.ts";
 import { textOutline } from "../page-furniture.ts";
+import { emailParts, emailVocabulary } from "../email-parts.ts";
 
 export type SourceInput = {
   readonly path: string;
@@ -9,8 +10,15 @@ export type SourceInput = {
   readonly language: string;
   readonly markdown: boolean;
   readonly profile?: DocumentProfile | undefined;
+  /** 言語パッケージの語彙表。メールの引用した返信を見分けて、木に入れない。無ければ見分けない。 */
+  readonly lexicons?: Readonly<Record<string, Lexicon>> | undefined;
 };
 
+const outlineOf = (input: SourceInput): Outline =>
+  input.markdown
+    ? markdownOutline(input.source, input.lexicons)
+    : textOutline(input.source, emailParts(input.source, emailVocabulary(input.lexicons ?? {})).replyQuotes);
+
 /**
  * 文字列から木を作る。Markdown なら見出しとコードの範囲を先に取る。
  * lint は文書モデルを作るときの解析を使い回すので、ここを通らずに buildTree を呼ぶ。
@@ -21,7 +29,7 @@ export const buildStructure = (input: SourceInput, patterns: StructurePatterns):
       path: input.path,
       source: input.source,
       language: input.language,
-      outline: input.markdown ? markdownOutline(input.source) : textOutline(input.source),
+      outline: outlineOf(input),
       markdown: input.markdown,
       profile: input.profile,
     },

package/src/structure/percent-sum.ts

@@ -0,0 +1,135 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, TABLE_ROW, TABLE_RULE, type Line } from "./runs.ts";
+import { columnOf, isTotalLabel, type Amount } from "./total.ts";
+import { CELL_SEPARATOR } from "./bare-numbers.ts";
+import { joined, lineAbove, linesAbove } from "../text-above.ts";
+
+/**
+ * 一つの全体を分けた割合（構成比、内訳、breakdown）の和が 100% にならない。箇条書きの続いた項目か、表の続いた行の百分率を足す。
+ * 全体を分けたものと読むのは、表のその列の見出しか、すぐ上の文や見出しに割合の語があるときだけ。行ごとの率（利用率）は足さない。
+ * 丸めの誤差は、項目ごとに最後の桁の半分まで認める（少なくとも 1 ポイント）。合計の行がある並びは total-mismatch に任せる。
+ */
+export type ShareWords = {
+  readonly labels: readonly string[];
+  /** 足しても 100% にならない集計（複数回答）。 */
+  readonly exceptions: readonly string[];
+  readonly units: readonly string[];
+  readonly totalLabels: readonly string[];
+};
+
+const WHOLE = 100;
+const MIN_PARTS = 2;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+type Share = Amount & { readonly column: number; readonly decimals: number; readonly signed: boolean };
+
+/** 数の前に書いた符号（+3%、-2%、▲2%）。増減の率で、全体の一部ではない。行頭の箇条書きの - は符号にしない。 */
+const SIGNS = "-+−▲△";
+
+const isSigned = (source: string, line: Line, offset: number): boolean => {
+  const before = source.slice(line.start, offset).trimEnd();
+  return SIGNS.includes(before.at(-1) ?? " ") && before.slice(0, -1).trim().length > 0;
+};
+const DECIMALS = /\.(\d+)/u;
+
+const includesAny = (text: string, words: readonly string[]): boolean => {
+  const lowered = text.toLowerCase();
+  return words.some((word) => lowered.includes(word.toLowerCase()));
+};
+
+/** 位置の順に並べた百分率のうち、offset 以後の最初のもの。 */
+const firstFrom = (percents: readonly Amount[], offset: number, low = 0, high = percents.length): number => {
+  if (low >= high) return low;
+  const middle = Math.floor((low + high) / 2);
+  return (percents[middle]?.offset ?? 0) < offset ? firstFrom(percents, offset, middle + 1, high) : firstFrom(percents, offset, low, middle);
+};
+
+/** 行の中の百分率。百分率は位置の順に並んでいるので、行の頭から探して行の終わりで止める。 */
+const onLine = (percents: readonly Amount[], line: Line): Amount[] => {
+  const from = firstFrom(percents, line.start);
+  const past = firstFrom(percents, line.end + 1, from);
+  return percents.slice(from, past);
+};
+
+const sharesIn = (source: string, line: Line, percents: readonly Amount[]): Share[] =>
+  onLine(percents, line).map((amount) => ({
+    ...amount,
+    column: columnOf(source, line, amount.offset),
+    signed: isSigned(source, line, amount.offset),
+    decimals: DECIMALS.exec(source.slice(amount.offset, amount.end))?.[1]?.length ?? 0,
+  }));
+
+/** 表の見出しの行の升。区切りの行のすぐ上の行。表でなければ無い。 */
+const headerCells = (source: string, firstRow: Line): string[] => {
+  const rule = lineAbove(source, firstRow.start);
+  if (rule === undefined || !TABLE_RULE.test(rule.text)) return [];
+  const header = lineAbove(source, rule.start);
+  return header === undefined ? [] : header.text.split(CELL_SEPARATOR);
+};
+
+/** 並びのすぐ上の文か見出し。表なら見出しの行と区切りの行を飛ばして、その上。 */
+const textAbove = (source: string, run: readonly Line[]): string => {
+  const first = run[0];
+  return first === undefined
+    ? ""
+    : (joined(
+        source,
+        linesAbove(source, first.start, (text) => TABLE_ROW.test(text)),
+      )?.text ?? "");
+};
+
+/** 列の百分率。どの行にもちょうど一つあり、符号の無いときだけ。 */
+const columnShares = (rows: readonly Share[][], column: number): Share[] | undefined => {
+  const cells = rows.map((row) => row.filter((share) => share.column === column));
+  if (cells.some((cell) => cell.length !== 1)) return undefined;
+  const shares = cells.flat();
+  return shares.some((share) => share.signed) ? undefined : shares;
+};
+
+const sumOf = (shares: readonly Share[]): number => shares.reduce((total, share) => total + share.value, 0);
+
+const decimalsOf = (shares: readonly Share[]): number => Math.max(0, ...shares.map((share) => share.decimals));
+
+/** 丸めで離れうる幅。項目ごとに最後の桁の半分、少なくとも 1 ポイント。 */
+const tolerance = (shares: readonly Share[]): number => Math.max(1, shares.length * HALF * DECIMAL_BASE ** -decimalsOf(shares));
+
+/** 和は、項目のいちばん細かい桁で、最初の項目の単位を付けて見せる。 */
+const shownSum = (shares: readonly Share[]): string => `${sumOf(shares).toFixed(decimalsOf(shares))}${shares[0]?.unit ?? ""}`;
+
+type Named = { readonly header: readonly string[]; readonly above: string };
+
+/** 列が全体を分けた割合と名指されているか。表は列の見出しか、百分率の列が一つだけの表の上の文。箇条書きは上の文。 */
+const namesShares = (named: Named, column: number, percentColumns: number, words: ShareWords): boolean => {
+  const header = named.header[column] ?? "";
+  if (named.header.length > 0 && includesAny(header, words.labels)) return true;
+  return (named.header.length === 0 || percentColumns === 1) && includesAny(named.above, words.labels);
+};
+
+/** 足してよい並び: 二行以上で、合計の行が無い。 */
+const isBreakdown = (source: string, run: readonly Line[], totalLabels: readonly string[]): boolean =>
+  run.length >= MIN_PARTS && !run.some((line) => isTotalLabel(source.slice(line.start, line.end), totalLabels));
+
+const namingOf = (source: string, run: readonly Line[], first: Line): Named => ({ header: headerCells(source, first), above: textAbove(source, run) });
+
+const mismatchesIn = (source: string, run: readonly Line[], percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  const first = run[0];
+  if (first === undefined || !isBreakdown(source, run, words.totalLabels)) return [];
+  const rows = run.map((line) => sharesIn(source, line, percents));
+  const columns = [...new Set((rows[0] ?? []).map((share) => share.column))];
+  if (columns.length === 0) return [];
+  const named = namingOf(source, run, first);
+  if (includesAny([...named.header, named.above].join(" "), words.exceptions)) return [];
+  return columns.flatMap((column) => {
+    const shares = columnShares(rows, column);
+    if (shares === undefined || !namesShares(named, column, columns.length, words)) return [];
+    if (Math.abs(sumOf(shares) - WHOLE) <= tolerance(shares)) return [];
+    return [{ offset: shares[0]?.offset ?? first.start, values: { sum: shownSum(shares) } }];
+  });
+};
+
+export const percentSumMismatches = (source: string, amounts: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const percents = amounts.filter((amount) => words.units.includes(amount.unit)).toSorted((a, b) => a.offset - b.offset);
+  return runsOf(source).flatMap((run) => mismatchesIn(source, run, percents, words));
+};

package/src/structure/quoted-number.ts

@@ -0,0 +1,36 @@
+import type { StructureNode } from "../plugin.ts";
+
+type Visit = { readonly node: StructureNode; readonly leaving: boolean };
+
+const keyOf = (node: StructureNode): string | undefined => (node.ordinal === undefined || node.address === "" ? undefined : `${node.kind}/${node.address}`);
+
+/** 開いた節を番地ごとに積む。同じ番地の節がもう開いていれば、その一番近いものが中に自分の番号を持つ。 */
+const enter = (open: Map<string, StructureNode[]>, key: string, node: StructureNode, quoting: Set<StructureNode>): void => {
+  const holders = open.get(key) ?? [];
+  const nearest = holders.at(-1);
+  if (nearest !== undefined) quoting.add(nearest);
+  holders.push(node);
+  open.set(key, holders);
+};
+
+/**
+ * 同じ種類・同じ番地の番号付きの節を中に持つ節。自分の中に自分は無いので、これはこの文書の番号ではなく、
+ * 書き方の手本（「§ 163.25」の下に書き直した「§ 163.25」）のように、ほかの文書の条を名前として引いている。
+ * 木を一度だけ歩く。一番近い祖先だけに印を付ければ、その外側は内側の祖先が付ける。深い木でも再帰しない。
+ */
+export const numbersQuotedInside = (tree: StructureNode): ReadonlySet<StructureNode> => {
+  const quoting = new Set<StructureNode>();
+  const open = new Map<string, StructureNode[]>();
+  const pending: Visit[] = [{ node: tree, leaving: false }];
+  for (let visit = pending.pop(); visit !== undefined; visit = pending.pop()) {
+    const key = keyOf(visit.node);
+    if (visit.leaving) {
+      if (key !== undefined) open.get(key)?.pop();
+      continue;
+    }
+    if (key !== undefined) enter(open, key, visit.node, quoting);
+    pending.push({ node: visit.node, leaving: true });
+    visit.node.children.toReversed().forEach((child) => pending.push({ node: child, leaving: false }));
+  }
+  return quoting;
+};

package/src/structure/relative-find.ts

@@ -1,4 +1,7 @@
 import type { DocumentProfile, Mention, RelativeVocabulary, Span } from "../plugin.ts";
+import { isOneCharacter, withoutClosedPairs } from "./closed-pairs.ts";
+import { asideDepth, characters, type AsideDepth } from "./aside-depth.ts";
+import { knownMentions, type KnownMentions } from "./known-mentions.ts";
 
 /**
  * 前条・次項・同号・本条・前各項・前二項・前条第二項、条を書かない「第一項」を行の中から探す。語は文書の種類（profiles/*.yaml）が決める。
@@ -74,17 +77,6 @@ const countOf = (count: string | undefined, vocabulary: RelativeVocabulary, numb
 
 type Substitution = NonNullable<RelativeVocabulary["substitution"]>;
 
-/** 文字と、その位置（UTF-16 の単位で）。絵文字のような 2 単位の文字も 1 文字として読む。 */
-const characters = (text: string): { readonly char: string; readonly at: number }[] => {
-  const found: { char: string; at: number }[] = [];
-  let at = 0;
-  for (const char of text) {
-    found.push({ char, at });
-    at += char.length;
-  }
-  return found;
-};
-
 /** 一番外側の括弧の範囲。閉じの無い開きは捨てる。 */
 const outerQuotes = (text: string, quote: Substitution): Span[] => {
   const spans: Span[] = [];
@@ -118,20 +110,23 @@ export const substitutedDocuments = (mentions: readonly Mention[], text: string,
   );
 };
 
-/** 閉じた括弧書きを内側から外す。 */
+/**
+ * 閉じた括弧書きを内側から外す。開きと閉じが 1 字ずつなら、組ごと 1 度で外す（深い入れ子でも本文を読み直さない）。
+ * 2 字以上の括弧は、内側の組を外すのを変わらなくなるまで繰り返す。
+ */
 const withoutAsides = (gap: string, aside: RelativeVocabulary["aside"]): string => {
   if (aside === undefined) return gap;
+  if (isOneCharacter(aside.open) && isOneCharacter(aside.close)) return withoutClosedPairs(gap, aside.open, aside.close);
   const inner = new RegExp(`${escape(aside.open)}[^${escape(aside.open)}${escape(aside.close)}]*${escape(aside.close)}`, "gu");
-  const once = gap.replace(inner, "");
-  return once === gap ? gap : withoutAsides(once, aside);
+  let rest = gap;
+  for (let once = rest.replace(inner, ""); once !== rest; once = rest.replace(inner, "")) rest = once;
+  return rest;
 };
 
 /** あいだが、並びをつなぐもの・つなぎの語・閉じた括弧書き・空白だけか。 */
 const onlyJoins = (gap: string, patterns: Compiled, vocabulary: RelativeVocabulary): boolean =>
   withoutAsides(gap, vocabulary.aside).replace(patterns.joins, "").trim() === "";
 
-const overlaps = (start: number, end: number, others: readonly Mention[]): boolean => others.some((other) => start < other.end && other.start < end);
-
 /** 行き先を決められない番地。並びの続きを止めるためだけに覚え、参照にはしない。 */
 const OPAQUE = "opaque";
 
@@ -154,53 +149,45 @@ const bareCandidates = (text: string, patterns: Compiled, vocabulary: RelativeVo
 /** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。 */
 type BareWay = { readonly way: string; readonly continues?: Mention | undefined };
 
-/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。 */
-const wayOfBare = (text: string, bare: Bare, known: readonly Mention[], patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+/** 本文と、その括弧書きの深さ。並びは同じ深さの参照どうしでつながる。 */
+type Line = { readonly text: string; readonly asides: AsideDepth };
+
+/**
+ * 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。
+ * 前の参照とつながらなくても、参照の直後に開いた括弧書きの中なら、その参照の続き。
+ * 「第二十七条（第四項を除き、第五項及び第六項の規定を…）」の番地は、どれも第二十七条の中。
+ */
+const wayOfBare = (line: Line, bare: Bare, known: KnownMentions, patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+  const { text, asides } = line;
   if (glued(text, bare.start, patterns)) return { way: OPAQUE };
-  const depth = openAsides(text, bare.start, vocabulary).length;
-  const sameDepth = known.filter((other) => other.end <= bare.start && openAsides(text, other.end, vocabulary).length === depth);
-  const previous = sameDepth.toSorted((left, right) => left.end - right.end).at(-1);
+  const previous = known.previous(bare.start, asides.depth(bare.start));
   const joined = previous !== undefined && onlyJoins(text.slice(previous.end, bare.start), patterns, vocabulary) ? previous : undefined;
-  const continues = joined ?? ownerOfAside(text, bare.start, known, vocabulary);
+  const open = asides.innermost(bare.start);
+  const continues = joined ?? (open === undefined ? undefined : known.endingAt(open));
   if (continues === undefined) return { way: "current" };
   return continues.attrs["relative"] === OPAQUE ? { way: OPAQUE } : { way: "continue", continues };
 };
 
-/** at の位置で開いたままの括弧書きの開きの位置。並びは同じ深さの参照どうしでつながる。 */
-const openAsides = (text: string, at: number, vocabulary: RelativeVocabulary): number[] => {
-  const aside = vocabulary.aside;
-  const opens: number[] = [];
-  if (aside === undefined) return opens;
-  characters(text.slice(0, at)).forEach(({ char, at: position }) => {
-    if (char === aside.open) opens.push(position);
-    if (char === aside.close) opens.pop();
-  });
-  return opens;
-};
-
-/**
- * 参照の直後に開いた括弧書きの中なら、その参照。「第二十七条（第四項を除き、第五項及び第六項の規定を…）」の番地は、どれも第二十七条の中。
- */
-const ownerOfAside = (text: string, at: number, known: readonly Mention[], vocabulary: RelativeVocabulary): Mention | undefined => {
-  const open = openAsides(text, at, vocabulary).at(-1);
-  return open === undefined ? undefined : known.find((other) => other.end === open);
-};
-
 /**
  * 条を書かない「第一項」。すぐ前の参照とのあいだがつなぎの語だけなら、その参照の続き（continue）。
  * そうでなければ、書いた場所を含む一つ上のまとまり（current）の中。
  */
 const bareMentions = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader, before: readonly Mention[]): Mention[] => {
+  const candidates = bareCandidates(text, patterns, vocabulary, number);
+  if (candidates.length === 0) return [];
+  const line = { text, asides: asideDepth(text, vocabulary.aside) };
+  const known = knownMentions(before, line.asides.depth);
   const found: Mention[] = [];
-  bareCandidates(text, patterns, vocabulary, number).forEach((bare) => {
-    const known = [...before, ...found];
-    if (overlaps(bare.start, bare.end, known)) return;
-    const { way, continues } = wayOfBare(text, bare, known, patterns, vocabulary);
+  candidates.forEach((bare) => {
+    if (known.overlaps(bare.start, bare.end)) return;
+    const { way, continues } = wayOfBare(line, bare, known, patterns, vocabulary);
     // 条を書かない番地は、その一つ上（level）ではなく、書いた単位（level + 1）から名指しする。「第一項」は「同条」の行き先を変えない。
     // continues は、続きの元の参照がどれだけ前から始まるか。木の中で、その参照を位置で引く。
     const back = continues === undefined ? {} : { continues: bare.start - continues.start };
     const attrs = { label: bare.label, relative: way, level: bare.first - 1, count: 1, suffix: bare.suffix, names: bare.first, ...back };
-    found.push({ start: bare.start, end: bare.end, attrs });
+    const mention = { start: bare.start, end: bare.end, attrs };
+    found.push(mention);
+    known.add(mention, line.asides.depth(mention.end));
   });
   return found.filter((mention) => mention.attrs["relative"] !== OPAQUE);
 };

package/src/structure/relative-resolve.ts

@@ -1,4 +1,5 @@
 import type { StructureNode } from "../plugin.ts";
+import { preOrder } from "../tree-walk.ts";
 
 /**
  * 相対の参照（relative-find.ts が見つけたもの）に番地を与える。木ができてからでないと「次条」は決まらないので、ここは木を読むだけの後段。
@@ -24,11 +25,18 @@ const placeOf = (node: StructureNode): Place | undefined =>
   NUMBERED.has(node.kind) && node.level !== undefined ? { address: node.address, level: node.level, range: node.ordinalTo !== undefined } : undefined;
 
 /** 番号の付いた子。Markdown の見出し（section）は番号の外なので、その中まで見る。 */
-const numberedChildren = (node: StructureNode, level: number): StructureNode[] =>
-  node.children.flatMap((child) => {
-    if (NUMBERED.has(child.kind)) return child.level === level ? [child] : [];
-    return child.kind === "section" ? numberedChildren(child, level) : [];
-  });
+const numberedChildren = (node: StructureNode, level: number): StructureNode[] => {
+  const found: StructureNode[] = [];
+  const pending = node.children.toReversed();
+  while (pending.length > 0) {
+    const child = pending.pop();
+    if (child === undefined) break;
+    if (NUMBERED.has(child.kind)) {
+      if (child.level === level) found.push(child);
+    } else if (child.kind === "section") child.children.toReversed().forEach((inner) => pending.push(inner));
+  }
+  return found;
+};
 
 type Context = {
   readonly articles: readonly Place[];
@@ -182,27 +190,65 @@ const resolveOne = (node: StructureNode, path: readonly StructureNode[], context
 
 const isRelative = (node: StructureNode): boolean => node.kind === "reference" && node.attrs["relative"] !== undefined;
 
-/** 文書の順に読み、参照ごとに「その前の参照」を覚える。 */
-const walk = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
-  if (isRelative(node)) {
-    const resolved = resolveOne(node, path, context);
-    if (resolved === undefined) return undefined;
-    const reference = lastOf(resolved);
-    context.byStart.set(node.span.start, reference);
-    remember(context, reference, Number(node.attrs["names"] ?? node.attrs["level"]));
-    return resolved;
-  }
-  if (node.kind === "reference") {
-    const reference = lastOf(node);
-    context.byStart.set(node.span.start, reference);
-    remember(context, reference, context.articleLevel ?? 0);
+/** 相対の参照に番地を決めて、その番地を覚える。決まらなければ木から外す（undefined）。 */
+const resolvedReference = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
+  const resolved = resolveOne(node, path, context);
+  if (resolved === undefined) return undefined;
+  const reference = lastOf(resolved);
+  context.byStart.set(node.span.start, reference);
+  remember(context, reference, Number(node.attrs["names"] ?? node.attrs["level"]));
+  return resolved;
+};
+
+/** 番地を名指した参照の番地を覚える。 */
+const noteReference = (node: StructureNode, context: Context): void => {
+  if (node.kind !== "reference") return;
+  const reference = lastOf(node);
+  context.byStart.set(node.span.start, reference);
+  remember(context, reference, context.articleLevel ?? 0);
+};
+
+/** 子を読んでいる節点。next は次に読む子。 */
+type Visit = { readonly node: StructureNode; readonly kept: StructureNode[]; next: number };
+
+/** 読み終えた節点を、残した子で作り直して親に渡す。親が無ければ（根なら）それを返す。 */
+const close = (visits: Visit[]): StructureNode | undefined => {
+  const visit = visits.pop();
+  if (visit === undefined) return undefined;
+  const rebuilt = { ...visit.node, children: visit.kept };
+  const parent = visits.at(-1);
+  if (parent === undefined) return rebuilt;
+  parent.kept.push(rebuilt);
+  return undefined;
+};
+
+/** 文書の順に読み、参照ごとに「その前の参照」を覚える。相対の参照は置き換えて、その中は読まない。 */
+const walk = (tree: StructureNode, context: Context): StructureNode | undefined => {
+  if (isRelative(tree)) return resolvedReference(tree, [], context);
+  noteReference(tree, context);
+  const visits: Visit[] = [{ node: tree, kept: [], next: 0 }];
+  while (visits.length > 0) {
+    const visit = visits.at(-1);
+    const child = visit?.node.children[visit.next];
+    if (visit === undefined || child === undefined) {
+      const root = close(visits);
+      if (root !== undefined) return root;
+      continue;
+    }
+    visit.next += 1;
+    if (isRelative(child)) {
+      const resolved = resolvedReference(
+        child,
+        visits.map((open) => open.node),
+        context,
+      );
+      if (resolved !== undefined) visit.kept.push(resolved);
+      continue;
+    }
+    noteReference(child, context);
+    visits.push({ node: child, kept: [], next: 0 });
   }
-  const inside = [...path, node];
-  const children = node.children.flatMap((child) => {
-    const kept = walk(child, inside, context);
-    return kept === undefined ? [] : [kept];
-  });
-  return { ...node, children };
+  return undefined;
 };
 
 const optional = (value: string | number | undefined): string | undefined => (value === undefined ? undefined : String(value));
@@ -213,12 +259,13 @@ const lastOf = (reference: StructureNode): Last => ({
   unitWord: optional(reference.attrs["unitWord"]),
 });
 
-const articlesOf = (node: StructureNode): Place[] => {
-  const place = node.kind === "article" ? placeOf(node) : undefined;
-  return [...(place === undefined ? [] : [place]), ...node.children.flatMap(articlesOf)];
-};
+const articlesOf = (root: StructureNode): Place[] =>
+  preOrder(root).flatMap((node) => {
+    const place = node.kind === "article" ? placeOf(node) : undefined;
+    return place === undefined ? [] : [place];
+  });
 
 export const resolveRelative = (tree: StructureNode, implicitLevel: number | undefined): StructureNode => {
   const articles = articlesOf(tree);
-  return walk(tree, [], { articles, articleLevel: articles[0]?.level, implicitLevel, last: new Map(), byStart: new Map() }) ?? tree;
+  return walk(tree, { articles, articleLevel: articles[0]?.level, implicitLevel, last: new Map(), byStart: new Map() }) ?? tree;
 };

package/src/structure/runs.ts

@@ -5,9 +5,9 @@
 type Kind = "list" | "table";
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
-const TABLE_ROW = /^[ \t]{0,12}\|/u;
+export const TABLE_ROW = /^[ \t]{0,12}\|/u;
 
-const TABLE_RULE = /^[ \t]{0,12}\|?[ \t]{0,4}:?-{3,}/u;
+export const TABLE_RULE = /^[ \t]{0,12}\|?[ \t]{0,4}:?-{3,}/u;
 const INDENT = /^[ \t]*/u;
 
 export type Line = { readonly start: number; readonly end: number; readonly kind: Kind | undefined; readonly indent: number; readonly rule: boolean };

package/src/structure/sexp.ts

@@ -20,9 +20,21 @@ const keywords = (node: StructureNode): string[] => [
  * 木を S 式にする。人と AI が読むための形で、JSON と同じ木から作る。
  * `(kind "番地" :key value ... 子)`。番地を持たない葉は番地を書かない。
  */
-export const toSexp = (node: StructureNode, indent = ""): string => {
-  const head = [node.kind, ...(node.address === "" ? [] : [quote(node.address)]), ...keywords(node)].join(" ");
-  if (node.children.length === 0) return `${indent}(${head})`;
-  const inner = node.children.map((child) => toSexp(child, `${indent}  `)).join("\n");
-  return `${indent}(${head}\n${inner})`;
+export const toSexp = (root: StructureNode, indent = ""): string => {
+  const lines: string[] = [];
+  // 1 行に 1 節点。節点を閉じる ")" は、その部分木の最後の行の後ろに付く。
+  const pending = [{ node: root, depth: 0, closing: false }];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === undefined) break;
+    if (next.closing) {
+      lines.push(`${lines.pop() ?? ""})`);
+      continue;
+    }
+    const head = [next.node.kind, ...(next.node.address === "" ? [] : [quote(next.node.address)]), ...keywords(next.node)].join(" ");
+    lines.push(`${indent}${"  ".repeat(next.depth)}(${head}`);
+    pending.push({ ...next, closing: true });
+    next.node.children.toReversed().forEach((child) => pending.push({ node: child, depth: next.depth + 1, closing: false }));
+  }
+  return lines.join("\n");
 };

package/src/structure/total.ts

@@ -27,7 +27,7 @@ type Cell = { readonly column: number; readonly unit: string };
 type Placed = Amount & Cell & { readonly cents: number | undefined };
 type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
 
-const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
+export const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
 
 const isNegative = (source: string, line: Line, amount: Amount): boolean => {
   const before = source.slice(line.start, amount.offset);
@@ -48,7 +48,7 @@ const leadingText = (text: string): string =>
  */
 const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
 
-const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
+export const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
   const lead = leadingText(text).toLowerCase();
   return labels.some((label) => lead.startsWith(label.toLowerCase()) && AFTER_LABEL.test(lead.slice(label.length)));
 };

package/src/structure/universal.ts

@@ -1,10 +1,16 @@
-import type { NumberedLine, NumberingContext } from "../plugin.ts";
+import type { NumberedLine, NumberingContext, StructurePatterns } from "../plugin.ts";
+import { numberInSentence } from "./number-in-sentence.ts";
 
 /**
  * 「4.2 設定」「3.1.4 Scope」のような通し番号。数字と点だけで書くので言語を問わない。
  * 各部分を 3 桁・深さを 6 までに抑え、後戻りが爆発しない形にしてある。
  */
-const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})\.?[ \t\u3000]+(?<rest>\S.*)$/u;
+const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>[.．])?[ \t\u3000]+(?<rest>\S.*)$/u;
+/**
+ * 見出しで、点で閉じた番号に題を詰めて書いたもの（「7.委託」「7．委託」「2.Overview」）。後ろが数字なら小数（「1.5万人」）、
+ * 小文字なら版（「2.x 系」）なので読まない。
+ */
+const TIGHT_HEADING = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>[.．])(?<rest>[^\s\d\p{Ll}.．].*)$/u;
 
 /**
  * RFC のようなテキストの仕様書（Markdown でないもの）の章見出し「5.  Security Considerations」。Markdown では、行内のコードを伏せた空白が
@@ -17,16 +23,38 @@ const MAX_TITLE = 80;
 
 const isTopSection = (line: string, rest: string): boolean => TOP_SECTION.test(line) && rest.length <= MAX_TITLE && !SENTENCE_END.test(rest);
 
+const dottedGroups = (line: string, context: NumberingContext): Readonly<Record<string, string | undefined>> | undefined =>
+  DOTTED.exec(line)?.groups ?? (context.isHeading ? TIGHT_HEADING.exec(line)?.groups : undefined);
+
+/** closedByDot: 番号を点で閉じたか（「5. 」）。「1.5 万人」の 1.5 は閉じていない。 */
+type DottedLine = NumberedLine & { readonly closedByDot: boolean };
+
 /**
  * 本文の「1. 」は箇条書きで、見出しの「1. 」は章番号。点を含まない番号は、見出しの行か、テキストの章見出しの形でだけ読む。
  * 「4.2 」のように点を含むものは、.txt の仕様書でも見出しとして書かれるので本文でも読む。
  */
-export const dottedNumber = (line: string, context: NumberingContext, plainText = false): NumberedLine | undefined => {
-  const groups = DOTTED.exec(line)?.groups;
+export const dottedNumber = (line: string, context: NumberingContext, plainText = false): DottedLine | undefined => {
+  const groups = dottedGroups(line, context);
   const number = groups?.["number"];
   if (number === undefined) return undefined;
   const depth = number.split(".").length;
   const rest = groups?.["rest"]?.trim() ?? "";
   if (depth < 2 && !context.isHeading && !(plainText && isTopSection(line, rest))) return undefined;
-  return { kind: "article", depth, number, absolute: true, label: number, heading: rest, rest, ordinal: Number(number.split(".").at(-1)) };
+  const closedByDot = groups?.["closing"] !== undefined;
+  return { kind: "article", depth, number, absolute: true, label: number, heading: rest, rest, ordinal: Number(number.split(".").at(-1)), closedByDot };
+};
+
+/**
+ * 番号の後ろが単位なら数量（「1.5 万人」「2.5 days」）。点で閉じた番号（「5. ページ自身の通信」「2. Days off」）は札で、
+ * 数量はそう書かないので、後ろに単位の語が来ても数量にしない。
+ */
+export const isAmount = (dotted: DottedLine, countedAfter: StructurePatterns["countedAfter"]): boolean =>
+  !dotted.closedByDot && countedAfter?.(dotted.number, dotted.rest) === true;
+
+/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
+export const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
+  const dotted = dottedNumber(text, context, plainText);
+  if (dotted === undefined || isAmount(dotted, patterns.countedAfter)) return undefined;
+  const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
+  return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
 };