chaffjs 0.8.0 → 0.10.0

package/src/structure/relative-resolve.ts

@@ -0,0 +1,209 @@
+import type { StructureNode } from "../plugin.ts";
+
+/**
+ * 相対の参照（relative-find.ts が見つけたもの）に番地を与える。木ができてからでないと「次条」は決まらないので、ここは木を読むだけの後段。
+ * 前・次は、書いた場所を含む同じ深さのまとまりの前後。条は文書を通して並ぶので文書全体、項と号は同じ親の中で数える。
+ * 同は、その前の参照（相対のものも含む）の番地を、その深さまで切ったもの。他の文書を指していれば、それも引き継ぐ。
+ * 番地を決められないもの（最初の条の「前条」、何も引いていない「同条」）は木から外す。当て推量の番地で誤りを言わない。
+ */
+
+/** range は「第四十三条から第五十五条まで 削除」のように、一行で並びをまとめたもの。番地は最初のものしか持たない。 */
+type Place = { readonly address: string; readonly level: number; readonly range?: boolean };
+
+type Last = { readonly target: string; readonly document: string | undefined };
+
+const NUMBERED = new Set(["chapter", "article", "item"]);
+
+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) : [];
+  });
+
+type Context = {
+  readonly articles: readonly Place[];
+  /** 条の深さ。同の番地を切るときの起点。 */
+  readonly articleLevel: number | undefined;
+  /** 最初のものに番号を振らない深さ（法令の項）。 */
+  readonly implicitLevel: number | undefined;
+  /** 深さごとに、最後に名指しされた番地。「前項」は項だけを名指しするので、「同条」の行き先を変えない。 */
+  readonly last: Map<number, Last>;
+  /** 参照を、始まる位置で引けるようにする。「若しくは第九項」のような並びの続きが、元の参照を引く。 */
+  readonly byStart: Map<number, Last>;
+};
+
+/** 同じ親の下で同じ深さのもの。番号の無い最初のもの（法令の第 1 項）があるなら、それを先頭に足す。 */
+const siblingsUnder = (parent: StructureNode, level: number, implicitLevel: number | undefined): Place[] => {
+  const children = numberedChildren(parent, level);
+  const explicit = children.flatMap((child) => {
+    const place = placeOf(child);
+    return place === undefined ? [] : [place];
+  });
+  const firstOrdinal = children[0]?.ordinal;
+  const implicit = level === implicitLevel && parent.level === level - 1 && firstOrdinal !== 1;
+  return implicit ? [{ address: `${parent.address}.1`, level }, ...explicit] : explicit;
+};
+
+type Anchor = { readonly place: Place; readonly siblings: readonly Place[] };
+
+/** 書いた場所を含む、その深さのまとまり。第 1 項の本文にいて項が開いていなければ、番号の無い第 1 項。 */
+const anchorAt = (path: readonly StructureNode[], level: number, context: Context): Anchor | undefined => {
+  const index = path.findLastIndex((node) => NUMBERED.has(node.kind) && node.level === level);
+  const node = path[index];
+  if (node !== undefined) {
+    const place = placeOf(node);
+    // 親は番号の付いた一つ上のまとまり。あいだの Markdown の見出しは飛ばす。無ければ文書（条より外のまとまり）。
+    const parent = path.slice(0, index).findLast((candidate) => NUMBERED.has(candidate.kind) && (candidate.level ?? 0) < level) ?? path[0];
+    if (place === undefined || parent === undefined) return undefined;
+    return { place, siblings: node.kind === "article" ? context.articles : siblingsUnder(parent, level, context.implicitLevel) };
+  }
+  const parent = path.findLast((candidate) => NUMBERED.has(candidate.kind) && candidate.level === level - 1);
+  if (level !== context.implicitLevel || parent === undefined) return undefined;
+  const siblings = siblingsUnder(parent, level, context.implicitLevel);
+  const first = siblings[0];
+  return first === undefined ? undefined : { place: first, siblings };
+};
+
+/**
+ * by だけ前後にずらす。範囲の行（第四十三条から第五十五条まで 削除）は中の条を一つずつ持たないので、数えてまたげば行き先がずれる。
+ * 前に数えて範囲をまたぐか範囲に当たる、後ろに数えて範囲をまたぐなら決めない。後ろに数えて範囲に当たるのは、その最初の条なので正しい。
+ */
+const shifted = (anchor: Anchor, by: number): Place | undefined => {
+  const index = anchor.siblings.findIndex((place) => place.address === anchor.place.address);
+  if (index === -1) return undefined;
+  const crossed = by > 0 ? anchor.siblings.slice(index + 1, index + by) : anchor.siblings.slice(Math.max(0, index + by), index);
+  return crossed.some((place) => place.range === true) ? undefined : anchor.siblings[index + by];
+};
+
+/** 前の全部（前各項）は、前に一つでもあれば最初のもの。 */
+const allBefore = (anchor: Anchor): Place | undefined => (shifted(anchor, -1) === undefined ? undefined : anchor.siblings[0]);
+
+/**
+ * 前・次・本で決まる場所。「各」（count 0）は前の全部なので、最初のものを指す。
+ */
+const byPosition = (way: string, count: number, anchor: Anchor): Place | undefined => {
+  if (way === "current") return anchor.place;
+  if (way === "after") return shifted(anchor, Math.max(count, 1));
+  return count === 0 ? allBefore(anchor) : shifted(anchor, -count);
+};
+
+/** 同: その前の参照の番地を、この深さまで切る。条より外のまとまりは番地の形が違うので扱わない。 */
+const bySame = (level: number, last: Last | undefined): Place | undefined => (last === undefined ? undefined : { address: last.target, level });
+
+/** 並びの続き: 元の参照の番地を、この深さまで切る。元の参照の番地が決まらなければ決めない。 */
+const continued = (level: number, node: StructureNode, context: Context): Last | undefined => {
+  const origin = context.byStart.get(node.span.start - Number(node.attrs["continues"]));
+  if (origin === undefined || context.articleLevel === undefined || level < context.articleLevel) return undefined;
+  const parts = origin.target.split(".");
+  const kept = level - context.articleLevel + 1;
+  return parts.length < kept ? undefined : { target: parts.slice(0, kept).join("."), document: origin.document };
+};
+
+/**
+ * 参照が名指しした深さを覚える。名指しは、書き出しの深さ（第〇条なら条、前項なら項）から番地の深さまで。
+ * 番地を深さで切る起点は条。条より外のまとまりは番地の形が違うので覚えない。
+ */
+const remember = (context: Context, target: string, document: string | undefined, from: number): void => {
+  const articleLevel = context.articleLevel;
+  // 章・節は番地の形（ch1）が条から始まらないので覚えない。覚えると「同条」が章を指してしまう。
+  if (articleLevel === undefined || from < articleLevel) return;
+  const parts = target.split(".");
+  parts.forEach((_, index) => {
+    const level = articleLevel + index;
+    if (level >= from) context.last.set(level, { target: parts.slice(0, index + 1).join("."), document });
+  });
+};
+
+/** 「第二項第三号」を足す。一つ深いものは続け、二つ深い号は番号の無い第 1 項の中（x.1.n）に置く。 */
+const withSuffix = (place: Place, suffix: string, implicitLevel: number | undefined): Place | undefined =>
+  suffix
+    .split(",")
+    .filter((part) => part !== "")
+    .reduce<Place | undefined>((current, part) => {
+      const [depth, value] = part.split(":").map(Number);
+      if (current === undefined || depth === undefined || value === undefined) return undefined;
+      if (depth === current.level + 1) return { address: `${current.address}.${String(value)}`, level: depth };
+      if (implicitLevel === current.level + 1 && depth === current.level + 2) return { address: `${current.address}.1.${String(value)}`, level: depth };
+      return undefined;
+    }, place);
+
+/** 番号の無い第 1 項（x.1）は、条そのものでもある。 */
+const fallbackOf = (place: Place, implicitLevel: number | undefined): string | undefined =>
+  place.level === implicitLevel && place.address.endsWith(".1") ? place.address.slice(0, -".1".length) : undefined;
+
+const baseOf = (way: string, node: StructureNode, anchor: Anchor | undefined, last: Last | undefined, context: Context): Place | undefined => {
+  const level = Number(node.attrs["level"]);
+  if (way === "same") return bySame(level, last);
+  if (way === "continue") {
+    const origin = continued(level, node, context);
+    return origin === undefined ? undefined : { address: origin.target, level };
+  }
+  return anchor === undefined ? undefined : byPosition(way, Number(node.attrs["count"]), anchor);
+};
+
+/** 同と並びの続きは、元の参照が他の文書を指していれば、それを引き継ぐ。前・次・本はこの文書の中。 */
+const documentOf = (way: string, node: StructureNode, last: Last | undefined, context: Context): string | undefined => {
+  if (way === "same") return last?.document;
+  return way === "continue" ? continued(Number(node.attrs["level"]), node, context)?.document : undefined;
+};
+
+const resolveOne = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
+  const way = String(node.attrs["relative"]);
+  const level = Number(node.attrs["level"]);
+  const last = context.last.get(level);
+  const anchor = way === "same" || way === "continue" ? undefined : anchorAt(path, level, context);
+  const base = baseOf(way, node, anchor, last, context);
+  const place = base === undefined ? undefined : withSuffix(base, String(node.attrs["suffix"] ?? ""), context.implicitLevel);
+  if (place === undefined) return undefined;
+  const fallback = fallbackOf(place, context.implicitLevel);
+  const document = documentOf(way, node, last, context);
+  const attrs = {
+    target: place.address,
+    label: String(node.attrs["label"]),
+    ...(fallback === undefined ? {} : { fallback }),
+    ...(document === undefined ? {} : { document }),
+  };
+  return { ...node, attrs };
+};
+
+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);
+    const target = resolved === undefined ? undefined : String(resolved.attrs["target"]);
+    const document = optional(resolved?.attrs["document"]);
+    if (target !== undefined) context.byStart.set(node.span.start, { target, document });
+    if (target !== undefined) remember(context, target, document, Number(node.attrs["names"] ?? node.attrs["level"]));
+    return resolved;
+  }
+  if (node.kind === "reference") {
+    const target = String(node.attrs["target"]);
+    const document = optional(node.attrs["document"]);
+    context.byStart.set(node.span.start, { target, document });
+    remember(context, target, document, context.articleLevel ?? 0);
+  }
+  const inside = [...path, node];
+  const children = node.children.flatMap((child) => {
+    const kept = walk(child, inside, context);
+    return kept === undefined ? [] : [kept];
+  });
+  return { ...node, children };
+};
+
+const optional = (value: string | number | undefined): string | undefined => (value === undefined ? undefined : String(value));
+
+const articlesOf = (node: StructureNode): Place[] => {
+  const place = node.kind === "article" ? placeOf(node) : undefined;
+  return [...(place === undefined ? [] : [place]), ...node.children.flatMap(articlesOf)];
+};
+
+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;
+};

package/src/structure/runs.ts

@@ -0,0 +1,71 @@
+/**
+ * 箇条書きと表の行の並び。続いた箇条書きの同じ深さの項目か、続いた表の行を一つの並びとして読む。
+ * 並びの中の値（日付、金額）を比べる rule が共通に使う。
+ */
+type Kind = "list" | "table";
+
+const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+const TABLE_ROW = /^[ \t]{0,12}\|/u;
+
+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 };
+
+const kindOf = (text: string): Kind | undefined => {
+  if (TABLE_ROW.test(text)) return "table";
+  return LIST_ITEM.test(text) ? "list" : undefined;
+};
+
+/** 先頭に | を書かない表（「Step | Date」「--- | ---」）の行。| のある見出しの下の区切り行から、| のある行が続くあいだ。 */
+const PIPELESS_RULE = /^[ \t]{0,12}:?-{3,}:?[ \t]{0,4}\|/u;
+
+const pipelessTableLines = (texts: readonly string[]): Set<number> => {
+  const inTable = new Set<number>();
+  texts.forEach((text, index) => {
+    if (!PIPELESS_RULE.test(text) || !(texts[index - 1] ?? "").includes("|")) return;
+    for (let row = index + 1; row < texts.length && (texts[row] ?? "").includes("|"); row += 1) inTable.add(row);
+  });
+  return inTable;
+};
+
+const linesOf = (source: string): Line[] => {
+  const texts = source.split("\n");
+  const pipeless = pipelessTableLines(texts);
+  const found: Line[] = [];
+  let start = 0;
+  texts.forEach((text, index) => {
+    const indent = INDENT.exec(text)?.[0].length ?? 0;
+    const kind = pipeless.has(index) ? "table" : kindOf(text);
+    found.push({ start, end: start + text.length, kind, indent, rule: TABLE_RULE.test(text) });
+    start += text.length + 1;
+  });
+  return found;
+};
+
+/**
+ * 続いた箇条書きや表の中で、同じ深さの行を一つの並びにする。
+ * 子の項目（深い字下げ）は親の並びを切らずに、親ごとに別の並びになる。浅い項目が来たら、それより深い並びは閉じる。
+ * 表の区切り行（|---|）のすぐ前の行は見出しなので、並びから外す。
+ */
+export const runsOf = (source: string): Line[][] => {
+  const runs: Line[][] = [];
+  const open = new Map<number, Line[]>();
+  const close = (deeperThan: number): void => [...open.keys()].filter((depth) => depth > deeperThan).forEach((depth) => open.delete(depth));
+  linesOf(source).forEach((line, index, all) => {
+    if (line.kind === undefined || all[index - 1]?.kind !== line.kind) close(-1);
+    if (line.kind === undefined) return;
+    if (line.rule) {
+      open.get(line.indent)?.pop();
+      return;
+    }
+    close(line.indent);
+    const run = open.get(line.indent) ?? [];
+    if (!open.has(line.indent)) {
+      open.set(line.indent, run);
+      runs.push(run);
+    }
+    run.push(line);
+  });
+  return runs;
+};

package/src/structure/total.ts

@@ -0,0 +1,157 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+
+/**
+ * 合計の行と、その上に並べた金額の和。箇条書きの続いた項目か、表の続いた行で、合計の語（合計・小計・Total）で始まる行を読む。
+ * 同じ単位で同じ列（箇条書きは一つの列）の金額を上から足し、合計の行の金額と合わなければ言う。
+ * 小計と税のあとの総計のように、足し方が何通りかある。どの足し方でも合わないときだけ言う。
+ */
+export type Amount = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: string };
+
+const CENTS = 100;
+const MIN_PARTS = 2;
+
+/** 金額の前に書いた負の印（-500、▲500、-$500）。行頭の箇条書きの - は印にしない。 */
+const NEGATIVE_BEFORE = /[-−▲△][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+
+/** 括弧に入れた金額（(1,200)）。会計では負の数だが、補足の金額とも読めて符号が決まらない。 */
+const OPEN_PAREN_BEFORE = /[(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+
+type Cell = { readonly column: number; readonly unit: string };
+/** cents が undefined の金額は、符号が決まらない。 */
+type Placed = Amount & Cell & { readonly cents: number | undefined };
+type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
+
+/** 表の列の区切り。\| は列の中に書いた | なので数えない。 */
+const CELL_SEPARATOR = /(?<!\\)\|/u;
+
+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);
+  const marker = NEGATIVE_BEFORE.exec(before);
+  return marker !== null && before.slice(0, marker.index).trim().length > 0;
+};
+
+/** 行の最初の文字列（表なら最初の列）から、強調の印と箇条書きの印を除いたもの。 */
+const leadingText = (text: string): string =>
+  text
+    .replace(/^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*\|?[ \t]*/u, "")
+    .replace(/^[*_]+/u, "")
+    .trimStart();
+
+/**
+ * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、括弧の注記（合計（税込））、金額。
+ * 「計画」や「Total conversion: 25%」のように語が続くものは合計の行ではない。
+ */
+const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
+
+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)));
+};
+
+const centsOf = (source: string, line: Line, amount: Amount): number | undefined => {
+  if (OPEN_PAREN_BEFORE.test(source.slice(line.start, amount.offset))) return undefined;
+  return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
+};
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], labels: readonly string[]): Entry => ({
+  label: isTotalLabel(source.slice(line.start, line.end), labels),
+  amounts: amounts
+    .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
+    .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
+});
+
+const sameCell = (a: Cell, b: Cell): boolean => a.column === b.column && a.unit === b.unit;
+
+const sumOf = (values: readonly number[]): number => values.reduce((sum, value) => sum + value, 0);
+
+type RowsAbove = { readonly parts: number[]; readonly totals: number[]; sinceLast: number[] };
+
+/** 行の中で、その列と単位の値。無ければ null、二つ以上あるか、列に別の単位しか無いか、符号が決まらなければ undefined。 */
+const valueIn = (entry: Entry, cell: Cell): number | null | undefined => {
+  const inColumn = entry.amounts.filter((amount) => amount.column === cell.column);
+  const matching = inColumn.filter((amount) => sameCell(amount, cell));
+  if (matching.length === 0) return inColumn.length === 0 ? null : undefined;
+  return matching.length === 1 ? matching[0]?.cents : undefined;
+};
+
+const addTo = (above: RowsAbove, entry: Entry, value: number): void => {
+  if (entry.label) {
+    above.totals.push(value);
+    above.sinceLast = [];
+    return;
+  }
+  above.parts.push(value);
+  above.sinceLast.push(value);
+};
+
+/**
+ * 合計の行より上の、同じ列と単位の値。項目の行と合計の行に分け、最後の合計の行より後の項目も取る。
+ * 足し方が決まらない行（valueIn が undefined）が一つでもあれば undefined。1.2万円と円のように単位が割れた列もここで止まる。
+ */
+const windowAbove = (entries: readonly Entry[], cell: Cell): RowsAbove | undefined => {
+  const values = entries.map((entry) => valueIn(entry, cell));
+  if (values.includes(undefined)) return undefined;
+  const above: RowsAbove = { parts: [], totals: [], sinceLast: [] };
+  entries.forEach((entry, index) => {
+    const value = values[index];
+    if (typeof value === "number") addTo(above, entry, value);
+  });
+  return above;
+};
+
+/** 足し方の候補: 上の項目すべて（小計を並べた総計もこれ）、最後の合計より後の項目、最後の合計にその後の項目。項目が無ければ小計の和だけ。 */
+const candidateSums = (above: RowsAbove): number[] => {
+  if (above.parts.length === 0) return [sumOf(above.totals)];
+  const last = above.totals.at(-1);
+  return [sumOf(above.parts), sumOf(above.sinceLast), ...(last === undefined ? [] : [last + sumOf(above.sinceLast)])];
+};
+
+/** 項目が無く小計だけが並ぶ表は、小計の和。 */
+const reportedSum = (above: RowsAbove): number => (above.parts.length === 0 ? sumOf(above.totals) : (above.totals.at(-1) ?? 0) + sumOf(above.sinceLast));
+
+/** 和と呼べるだけの行があるか。項目が二つ以上か、項目が無く小計が二つ以上。 */
+const enoughRows = (above: RowsAbove): boolean => above.parts.length >= MIN_PARTS || (above.parts.length === 0 && above.totals.length >= MIN_PARTS);
+
+/** 和は、合計の行と同じ小数の桁で見せる（$10,160.00 なら $10,260.00）。端数があれば 2 桁。 */
+const formatCents = (cents: number, written: string): string => {
+  const digits = Math.max(/\.\d{2}/u.test(written) ? 2 : 0, cents % CENTS === 0 ? 0 : 2);
+  return (cents / CENTS).toLocaleString("en-US", { minimumFractionDigits: digits, maximumFractionDigits: digits });
+};
+
+/** 数の前に書いた単位（$1,200、$ 1,200）の始まり。木の数量は数から始まるので、見せるときは前の単位も入れる。 */
+const unitStartBefore = (source: string, amount: Amount): number | undefined => {
+  const gap = /[ \t]/u.test(source[amount.offset - 1] ?? "") ? 1 : 0;
+  const start = amount.offset - gap - amount.unit.length;
+  return start >= 0 && source.slice(start, amount.offset - gap) === amount.unit ? start : undefined;
+};
+
+/** 合計の行に書いた金額と、上の和を、同じ書き方で見せる。 */
+const shownAmounts = (source: string, total: Amount, sumCents: number): Record<string, string> => {
+  const unitStart = unitStartBefore(source, total);
+  const written = source.slice(unitStart ?? total.offset, total.end);
+  const sum = formatCents(sumCents, written);
+  if (unitStart !== undefined) return { written, sum: `${source.slice(unitStart, total.offset)}${sum}` };
+  return { written, sum: written.endsWith(total.unit) ? `${sum}${total.unit}` : sum };
+};
+
+const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
+  entries.flatMap((entry, index) => {
+    if (!entry.label) return [];
+    return entry.amounts.flatMap((total) => {
+      const writtenCents = valueIn(entry, total);
+      const above = windowAbove(entries.slice(0, index), total);
+      if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || candidateSums(above).includes(writtenCents)) return [];
+      return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
+    });
+  });
+
+export const totalMismatches = (source: string, amounts: readonly Amount[], labels: readonly string[]): StructureIssue[] =>
+  runsOf(source).flatMap((run) =>
+    mismatchesIn(
+      source,
+      run.map((line) => entryOf(source, line, amounts, labels)),
+    ),
+  );

package/src/structure/unnumbered.ts

@@ -0,0 +1,33 @@
+import type { DocumentProfile, NumberedLine } from "../plugin.ts";
+
+/** 開いている単位と、その行の番号の後ろが本文だったか（見出しでなく）。見出しは前の行から付くことがあるので、行そのものを覚えておく。 */
+export type OpenUnit = { readonly numbered: NumberedLine; readonly bodyOnLine: boolean };
+
+type Rule = NonNullable<DocumentProfile["unnumbered"]>;
+
+const escape = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+const compiled = new Map<string, RegExp>();
+
+const patternOf = (indent: string): RegExp => {
+  const found = compiled.get(indent) ?? new RegExp(`^${escape(indent)}(?<rest>\\S.*)$`, "u");
+  compiled.set(indent, found);
+  return found;
+};
+
+/**
+ * 番号を書かない単位（古い法令は第 2 項以降に番号を振らず、字下げした行を新しい項にする）。
+ * inside の種類の単位の行に本文が続くときだけ、その中で開いている depth の単位の次（無ければ 2 番目）として読む。
+ * 番号を書いた単位（「２」）がすでにあれば、字下げは番号の代わりではない。
+ */
+export const unnumberedUnit = (line: string, open: readonly OpenUnit[], rule: Rule | undefined): NumberedLine | undefined => {
+  if (rule === undefined) return undefined;
+  const rest = patternOf(rule.indent).exec(line)?.groups?.["rest"];
+  if (rest === undefined) return undefined;
+  const holder = [...open].reverse().find((unit) => unit.numbered.kind === rule.inside);
+  if (holder === undefined || !holder.bodyOnLine) return undefined;
+  const previous = [...open].reverse().find((unit) => unit.numbered.depth === rule.depth)?.numbered;
+  if (previous !== undefined && previous.label !== "") return undefined;
+  const number = String((previous === undefined ? 1 : Number(previous.number)) + 1);
+  return { kind: "item", depth: rule.depth, number, absolute: false, label: "", heading: "", rest: rest.trim(), ordinal: Number(number) };
+};

package/src/structure/unread.ts

@@ -0,0 +1,39 @@
+import type { StructureNode } from "../plugin.ts";
+
+/**
+ * 番号の付いた条項が本文にあるのに、木にほとんど入っていない文書。PDF から取り出した契約書は、字下げが深かったり
+ * 行が本文につながったりして、番号の行として読めないことが多い。そのとき構造の rule は「0 件」ではなく「読めなかった」と言う。
+ */
+const NUMBERED = new Set(["chapter", "article", "item"]);
+
+/**
+ * 「11.3. Liability Cap」「2.1 Term」: 二段以上の番号と、大文字で始まる語。行頭か、文の区切り（「. 12.10. Waiver」）の後ろ。
+ * 語の後ろの番号（「Version 1.2 Released」「Figure 2.1 Revenue」）は条項ではない。
+ * 「1.   TERM OF CONTRACT」: 行頭の一段の番号と、大文字だけの語。本文の箇条書き（「1. First」）とは分ける。
+ */
+const CLAUSE_NUMBERS = [/(?:^[ \t]{0,20}|[.;:][ \t]{1,10})\d{1,3}(?:\.\d{1,3}){1,4}\.?[ \t]{1,10}\p{Lu}/gmu, /^[ \t]{0,20}\d{1,3}\.[ \t]{1,10}\p{Lu}{2}/gmu];
+
+/** 本文の条項番号がこれ以上あれば、番号で組んだ文書。 */
+const MIN_CLAUSES = 5;
+/** 木に入った番号が本文の条項番号のこの割合に届かなければ、読めていない。 */
+const READ_SHARE = 0.25;
+
+export type Unread = { readonly clauses: number; readonly units: number };
+
+const numberedUnits = (tree: StructureNode): number => {
+  let count = 0;
+  const pending: StructureNode[] = [tree];
+  for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+    if (NUMBERED.has(node.kind)) count += 1;
+    pending.push(...node.children);
+  }
+  return count;
+};
+
+/** 読めていなければ、本文の条項番号の数と木の番号の数。読めていれば undefined。 */
+export const unreadStructure = (source: string, tree: StructureNode): Unread | undefined => {
+  const clauses = CLAUSE_NUMBERS.reduce((total, pattern) => total + [...source.matchAll(pattern)].length, 0);
+  if (clauses < MIN_CLAUSES) return undefined;
+  const units = numberedUnits(tree);
+  return units < clauses * READ_SHARE ? { clauses, units } : undefined;
+};

package/src/structure/weekday.ts

@@ -0,0 +1,25 @@
+import type { StructureNode } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { inDocumentOrder } from "./issues.ts";
+
+// 日付と、その横に書いた曜日の食い違い。暦で決まるので、両方読めれば誤りは機械で言える。
+
+const FULL_DATE = /^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/u;
+
+/** 暦の曜日。日曜日が 0。存在しない日（2月30日）は undefined。 */
+export const weekdayOf = (value: string): number | undefined => {
+  const groups = FULL_DATE.exec(value)?.groups;
+  if (groups === undefined) return undefined;
+  const [year, month, day] = [Number(groups["y"]), Number(groups["m"]), Number(groups["d"])];
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date.getUTCDay() : undefined;
+};
+
+/** 年まで書いた日付で、書いた曜日が暦と違うもの。年の無い日付は曜日を決められないので見ない。 */
+export const weekdayMismatches = (tree: StructureNode): StructureIssue[] =>
+  inDocumentOrder(tree).flatMap((node) => {
+    const written = node.attrs["weekday"];
+    if (node.kind !== "date" || typeof written !== "number") return [];
+    const actual = weekdayOf(String(node.attrs["value"]));
+    return actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: String(node.attrs["value"]), written, actual } }];
+  });