chaffjs 0.17.0 → 0.18.0

package/src/structure/build.ts

@@ -6,11 +6,11 @@ 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 { numberInSentence } from "./number-in-sentence.ts";
+import { universalNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
 import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
+import { foldPostOrder } from "../tree-walk.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -151,14 +151,6 @@ const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder
   { kind: "date", find: (patterns, text) => patterns.dates?.(text) ?? [] },
 ];
 
-/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
-const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
-  const dotted = dottedNumber(text, context, plainText);
-  if (dotted === undefined || patterns.countedAfter?.(dotted.number, dotted.rest) === true) return undefined;
-  const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
-  return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
-};
-
 /** 行の中の定義・参照・義務・数量を、いま開いている最も内側の節点の子にする。 */
 const enclosingArticle = (state: State): Draft | undefined => state.stack.findLast((frame) => frame.draft.kind === "article")?.draft;
 
@@ -220,23 +212,28 @@ const extend = (state: State, end: number): void => {
   });
 };
 
-const freeze = (draft: Draft): StructureNode => ({
+const frozen = (draft: Draft, children: readonly StructureNode[]): StructureNode => ({
   kind: draft.kind,
   address: draft.address,
   span: { start: draft.start, end: draft.end },
   line: draft.line,
   attrs: draft.attrs,
-  children: draft.children.map(freeze),
+  children,
   ...(draft.ordinal === undefined ? {} : { ordinal: draft.ordinal }),
   ...(draft.level === undefined ? {} : { level: draft.level }),
   ...(draft.ordinalTo === undefined ? {} : { ordinalTo: draft.ordinalTo }),
   ...(draft.numbering === undefined ? {} : { numbering: draft.numbering }),
 });
 
-/** Markdown から取った手がかり。見出しと、中を読まない範囲（コード）。.txt はどちらも空。 */
-export type Outline = { readonly headings: readonly Heading[]; readonly opaque: readonly Span[] };
+const freeze = (root: Draft): StructureNode => foldPostOrder(root, (draft) => draft.children, frozen);
+
+/**
+ * Markdown から取った手がかり。見出しと、中を読まない範囲（コード）と、表。.txt はどれも空。
+ * 表の欄の数（版の番号 3.1.0）は値で、この文書の番号ではない。表の行は番号として読まず、数量や日付は読む。
+ */
+export type Outline = { readonly headings: readonly Heading[]; readonly opaque: readonly Span[]; readonly tables: readonly Span[] };
 
-export const NO_OUTLINE: Outline = { headings: [], opaque: [] };
+export const NO_OUTLINE: Outline = { headings: [], opaque: [], tables: [] };
 
 export type StructureInput = {
   readonly path: string;
@@ -298,11 +295,14 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
   return numbered === undefined || caption === undefined ? numbered : { ...numbered, heading: caption };
 };
 
-const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, next: string | undefined): void => {
+/** 行の周り。前の行は、前の行が見出しでなく自分が表の行でないときだけ渡す。表の行は番号として読まない。 */
+type Around = { readonly next: string | undefined; readonly previous: string | undefined; readonly inTable: boolean };
+
+const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, around: Around): void => {
   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 found = numberedLine(state, patterns, text, context);
+  const found = around.inTable ? undefined : 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);
@@ -315,7 +315,21 @@ const readLine = (state: State, patterns: StructurePatterns, line: Line, heading
   const scanned = numbered === undefined ? text : numbered.rest;
   const offset = Math.max(0, line.text.lastIndexOf(scanned));
   const onHeading = heading !== undefined;
-  if (scanned !== "") addLeaves(state, patterns, line, wrappedLine(scanned, onHeading, next), offset, onHeading);
+  // 番号付きの行は新しいまとまりの始まりなので、前の行の続きとして読まない。
+  const previous = numbered === undefined ? around.previous : undefined;
+  if (scanned !== "") addLeaves(state, patterns, line, wrappedLine(scanned, onHeading, around.next, previous), offset, onHeading);
+};
+
+/** 表の範囲に入る行の番号。表ごとに始まりと終わりの行を引くので、表の数に比例する。 */
+const tableLineNumbers = (lines: readonly Line[], tables: readonly Span[]): Set<number> => {
+  const numbers = new Set<number>();
+  tables.forEach((table) => {
+    const first = lineNumberAt(lines, table.start);
+    const last = lineNumberAt(lines, table.end);
+    if (first === undefined || last === undefined) return;
+    Array.from({ length: last - first + 1 }, (_, index) => numbers.add(first + index));
+  });
+  return numbers;
 };
 
 /**
@@ -340,8 +354,13 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
     captions: new Map(),
     plainText: !input.markdown,
   };
+  const inTable = tableLineNumbers(lines, outline.tables);
   lines.forEach((line, index) => {
-    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number), lines[index + 1]?.text);
+    // 見出しの後ろと表の行は、段落の折り返しではない。表のすぐ後ろの行は（GFM では）表の行になるので、表の中だけ見ればよい。
+    const apart = headings.has(line.number - 1) || inTable.has(line.number);
+    const previous = apart ? undefined : lines[index - 1]?.text;
+    const around = { next: lines[index + 1]?.text, previous, inTable: inTable.has(line.number) };
+    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number), around);
     // コードの行は覆って読まないが、開いている節の中身ではある。節の最後にコードブロックがあっても、範囲をそこまで伸ばす。
     else if (input.source.slice(line.start, line.start + line.text.length).trim() !== "") extend(state, line.start + line.text.length);
   });

package/src/structure/closed-pairs.ts

@@ -0,0 +1,20 @@
+/**
+ * 閉じた括弧の組を、中身ごと外す。入れ子は内側から外れる。閉じない開きと、開かない閉じは残す。
+ * open と close は 1 字ずつ。同じ字なら、前から順に組になる。「内側の組を外す」を繰り返すと、深さの数だけ本文を読み直すので、1 度だけ読む。
+ */
+export const withoutClosedPairs = (text: string, open: string, close: string): string => {
+  const kept: string[] = [];
+  const opens: number[] = [];
+  for (const char of text) {
+    const opened = char === close ? opens.pop() : undefined;
+    if (opened !== undefined) kept.splice(opened);
+    else {
+      if (char === open) opens.push(kept.length);
+      kept.push(char);
+    }
+  }
+  return kept.join("");
+};
+
+/** 1 字（サロゲートの対も 1 字）か。 */
+export const isOneCharacter = (text: string): boolean => [...text].length === 1;

package/src/structure/date-range.ts

@@ -0,0 +1,69 @@
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * 期間の終わりが始まりより前。二つの日付の間が範囲の記号（〜、–、through）だけか、開きの語（から）で終わりの日付に閉じの語（まで）が続くときを期間と読む。
+ * 比べるのは、両方が年月日か、両方が年月のときだけ。年の無い期間（12月28日〜1月4日）は年をまたぐかもしれない。
+ * 言語の知識（範囲の記号と語）は語彙表から受け取る。
+ */
+export type DatedSpan = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type RangeWords = {
+  /** それだけで期間を作る記号と語。 */
+  readonly connectors: readonly string[];
+  /** 終わりの日付に閉じの語が続くときだけ期間を作る語（から）。 */
+  readonly openers: readonly string[];
+  readonly closers: readonly string[];
+};
+
+const COMPARABLE = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u];
+
+const comparable = (start: string, end: string): boolean => COMPARABLE.some((pattern) => pattern.test(start) && pattern.test(end));
+
+/** 日付に添えた曜日（（水））と時刻（10:00）は、期間のつなぎ目ではないので読み飛ばす。 */
+const ASIDES = /[（(][^（()）\n]{1,6}[）)]|\d{1,2}[:：]\d{2}/gu;
+
+const bare = (text: string): string => text.replace(ASIDES, "").trim().toLowerCase();
+
+const isOneOf = (text: string, words: readonly string[]): boolean => words.some((word) => word.toLowerCase() === text);
+
+/** 行の終わりまでの、終わりの日付の後ろ。曜日と時刻を除いてから閉じの語を探す。 */
+const closedAfter = (source: string, end: DatedSpan, closers: readonly string[]): boolean => {
+  const lineEnd = source.indexOf("\n", end.end);
+  const after = source
+    .slice(end.end, lineEnd === -1 ? source.length : lineEnd)
+    .replace(ASIDES, "")
+    .trimStart();
+  return closers.some((closer) => after.startsWith(closer));
+};
+
+/**
+ * 二つの日付の間のつなぎ。行をまたぐなら、つなぎは前の行の終わりにあり、次の行は終わりの日付から始まるときだけ（期間は2026年4月1日〜↵2026年3月31日）。
+ * 次の行の頭の「- 」は箇条書きの印で、範囲の記号ではない（日付を並べた一覧）。
+ */
+const jointOf = (source: string, start: DatedSpan, end: DatedSpan): string | undefined => {
+  const [first = "", ...next] = source.slice(start.end, end.offset).split("\n");
+  return next.every((line) => line.trim() === "") ? bare(first) : undefined;
+};
+
+const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
+  const joint = jointOf(source, start, end);
+  if (joint === undefined) return false;
+  return isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers));
+};
+
+/** 書いたままの期間。行をまたいだ期間は一行にする。 */
+const writtenPeriod = (source: string, start: DatedSpan, end: DatedSpan): string =>
+  source
+    .slice(start.offset, end.end)
+    .split("\n")
+    .map((part) => part.trim())
+    .join(" ");
+
+/** 隣り合う二つの日付のうち、期間をなし、終わりが始まりより前のもの。期間の書き出しを指し、書いたままの期間を見せる。 */
+export const reversedRanges = (source: string, dates: readonly DatedSpan[], words: RangeWords): StructureIssue[] =>
+  dates.slice(1).flatMap((end, index) => {
+    const start = dates[index];
+    if (start === undefined || !comparable(start.value, end.value) || end.value >= start.value) return [];
+    if (!isRange(source, start, end, words)) return [];
+    return [{ offset: start.offset, values: { start: start.value, end: end.value, period: writtenPeriod(source, start, end) } }];
+  });

package/src/structure/known-mentions.ts

@@ -0,0 +1,96 @@
+import type { Mention } from "../plugin.ts";
+
+/**
+ * 条を書かない番地を読むときに引く、同じ行の既知の参照。before（名指しの参照）に、見つけた番地を順に足していく。
+ * 引くたびに全部をなめると、参照の数の二乗になる。before は並べ替えて二分探索で、足したものは深さごとに最後の一つで引く。
+ *
+ * 足すものは、正規表現で左から見つけた番地の順に来る。だから足したものの終わりは、次に引く位置より前にあり、並びの順に増える。
+ * - overlaps: [start, end) と重なるものがあるか。足したものは引く位置より前で終わるので、重ならない。
+ * - previous: 終わりが at 以前で、終わりの深さが depth のもののうち、終わりが最も後ろのもの。同じ終わりなら後から知ったもの。
+ * - endingAt: 終わりが at のもののうち、最初に知ったもの。
+ */
+export type KnownMentions = {
+  readonly overlaps: (start: number, end: number) => boolean;
+  readonly previous: (at: number, depth: number) => Mention | undefined;
+  readonly endingAt: (at: number) => Mention | undefined;
+  readonly add: (mention: Mention, depth: number) => void;
+};
+
+/** sorted の中で、pass が偽になる最初の位置。pass は先頭から真が続き、あとは偽。 */
+const firstFailing = <T>(sorted: readonly T[], pass: (item: T) => boolean): number => {
+  let [low, high] = [0, sorted.length];
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    const item = sorted[middle];
+    if (item !== undefined && pass(item)) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+};
+
+/** 始まりの順に並べ、そこまでの終わりの最大を添える。始まりが end より前のものの、終わりの最大が start より後ろなら重なる。 */
+const overlapIndex = (before: readonly Mention[]): ((start: number, end: number) => boolean) => {
+  const byStart = before.filter((mention) => !Number.isNaN(mention.start)).toSorted((left, right) => left.start - right.start);
+  let reach = -Infinity;
+  const reaches = byStart.map((mention) => {
+    reach = Math.max(reach, Number.isNaN(mention.end) ? -Infinity : mention.end);
+    return reach;
+  });
+  return (start, end) => {
+    const count = firstFailing(byStart, (mention) => mention.start < end);
+    return count > 0 && (reaches[count - 1] ?? -Infinity) > start;
+  };
+};
+
+type Ranked = { readonly mention: Mention; readonly order: number };
+
+const byEndThenOrder = (left: Ranked, right: Ranked): number => {
+  if (left.mention.end !== right.mention.end) return left.mention.end < right.mention.end ? -1 : 1;
+  return left.order - right.order;
+};
+
+/** 深さごとに、終わりの順（同じなら知った順）に並べる。 */
+const previousIndex = (before: readonly Mention[], depthOf: (at: number) => number): ((at: number, depth: number) => Mention | undefined) => {
+  const byDepth = new Map<number, Ranked[]>();
+  before.forEach((mention, order) => {
+    if (Number.isNaN(mention.end)) return;
+    const depth = depthOf(mention.end);
+    const ranked = byDepth.get(depth) ?? [];
+    ranked.push({ mention, order });
+    byDepth.set(depth, ranked);
+  });
+  const sorted = new Map([...byDepth].map(([depth, ranked]) => [depth, ranked.toSorted(byEndThenOrder)]));
+  return (at, depth) => {
+    const ranked = sorted.get(depth) ?? [];
+    return ranked[firstFailing(ranked, (entry) => entry.mention.end <= at) - 1]?.mention;
+  };
+};
+
+const firstByEnd = (mentions: readonly Mention[]): Map<number, Mention> => {
+  const found = new Map<number, Mention>();
+  mentions.forEach((mention) => {
+    if (!found.has(mention.end)) found.set(mention.end, mention);
+  });
+  return found;
+};
+
+export const knownMentions = (before: readonly Mention[], depthOf: (at: number) => number): KnownMentions => {
+  const overlapsBefore = overlapIndex(before);
+  const previousBefore = previousIndex(before, depthOf);
+  const endsBefore = firstByEnd(before);
+  const lastAddedByDepth = new Map<number, Mention>();
+  const endsAdded = new Map<number, Mention>();
+  return {
+    overlaps: overlapsBefore,
+    previous: (at, depth) => {
+      const known = previousBefore(at, depth);
+      const added = lastAddedByDepth.get(depth);
+      return added !== undefined && (known === undefined || added.end >= known.end) ? added : known;
+    },
+    endingAt: (at) => endsBefore.get(at) ?? endsAdded.get(at),
+    add: (mention, depth) => {
+      lastAddedByDepth.set(depth, mention);
+      if (!endsAdded.has(mention.end)) endsAdded.set(mention.end, mention);
+    },
+  };
+};

package/src/structure/numbering.ts

@@ -1,5 +1,6 @@
 import type { StructureNode } from "../plugin.ts";
 import { inDocumentOrder, type StructureIssue } from "./issues.ts";
+import { numbersQuotedInside } from "./quoted-number.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
@@ -9,10 +10,10 @@ type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonl
  * 同じ親の子のうち、番号の付いたものを種類と深さごとに分ける。条と項は別の並び、項と号も別の並び。
  * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
  */
-const sequencesOf = (parent: StructureNode): Ordered[][] => {
+const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
   parent.children.forEach((node) => {
-    if (node.ordinal === undefined) return;
+    if (node.ordinal === undefined || quoting.has(node)) return;
     const key = `${node.kind}/${String(node.level ?? "")}`;
     // 配列を作り直さずに足す。条が何千もある法令で二乗にしない。
     const group = groups.get(key) ?? [];
@@ -41,9 +42,12 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
  * 番号の抜けと重なり。比べるのは同じ親の子どうしだけ。英米の法令は章ごとに Section 101、201 と百の位を変えるので、
  * 文書全体の通し番号として比べると抜けに見える。最初の番号は見ない。日本語の項は 2 から番号を振る。
  * 1 に戻った番号は新しい並びの始まりとして扱うので、「(a) の後の (a)」の重なりは見逃す。
+ * 同じ番号の節を中に持つ節（ほかの文書の条を引いた手本の見出し）は、並びに入れない。
  */
-export const numberingBreaks = (tree: StructureNode): StructureIssue[] =>
-  inDocumentOrder(tree)
-    .flatMap(sequencesOf)
+export const numberingBreaks = (tree: StructureNode): StructureIssue[] => {
+  const quoting = numbersQuotedInside(tree);
+  return inDocumentOrder(tree)
+    .flatMap((parent) => sequencesOf(parent, quoting))
     .flatMap(breaksIn)
     .toSorted((left, right) => left.offset - right.offset);
+};

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