chaffjs 0.8.0 → 0.9.0

package/src/structure/relative-find.ts

@@ -0,0 +1,224 @@
+import type { DocumentProfile, Mention, RelativeVocabulary, Span } from "../plugin.ts";
+
+/**
+ * 前条・次項・同号・本条・前各項・前二項・前条第二項、条を書かない「第一項」を行の中から探す。語は文書の種類（profiles/*.yaml）が決める。
+ * ここでは番地を決めず、何をどれだけ指すかだけを attrs に残す。番地は木ができてから relative-resolve.ts が決める。
+ */
+type RelativeWay = "before" | "after" | "same" | "current" | "continue";
+
+type NumberReader = (text: string) => number | undefined;
+
+const escape = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : words.map(escape).join("|"));
+
+type Compiled = {
+  readonly named: RegExp;
+  readonly bare: RegExp | undefined;
+  readonly suffix: RegExp;
+  readonly notAfter: RegExp | undefined;
+  readonly joins: RegExp;
+  readonly ways: ReadonlyMap<string, RelativeWay>;
+};
+
+const waysOf = (vocabulary: RelativeVocabulary): Map<string, RelativeWay> =>
+  new Map<string, RelativeWay>([
+    ...vocabulary.before.map((word): [string, RelativeWay] => [word, "before"]),
+    ...vocabulary.after.map((word): [string, RelativeWay] => [word, "after"]),
+    ...vocabulary.same.map((word): [string, RelativeWay] => [word, "same"]),
+    ...vocabulary.current.map((word): [string, RelativeWay] => [word, "current"]),
+  ]);
+
+/** 後ろの決まり: 番地の並びと同じく、つなぎの語を挟んで address_end。「前条件」の「前条」を参照にしない。 */
+const endOf = (profile: DocumentProfile): string => {
+  const connectives = profile.connectives.length === 0 ? "" : `(?:${oneOf(profile.connectives)})*`;
+  return profile.addressEnd === undefined ? "" : `(?=${connectives}(?:${profile.addressEnd}))`;
+};
+
+const compile = (profile: DocumentProfile, vocabulary: RelativeVocabulary): Compiled => {
+  const units = oneOf(Object.keys(vocabulary.units));
+  const suffix = `${escape(vocabulary.suffixPrefix)}(?:${vocabulary.count})(?:${units})`;
+  const end = endOf(profile);
+  const start = vocabulary.notAfter === undefined ? "" : `(?<!${vocabulary.notAfter})`;
+  const way = oneOf([...vocabulary.before, ...vocabulary.after, ...vocabulary.same, ...vocabulary.current]);
+  const count = `${oneOf(vocabulary.every)}|${vocabulary.count}`;
+  const inside = `${escape(vocabulary.suffixPrefix)}(?:${vocabulary.count})(?:${oneOf(vocabulary.inside)})`;
+  return {
+    named: new RegExp(`${start}(?<way>${way})(?<count>${count})?(?<unit>${units})(?<suffix>(?:${suffix})*)${end}`, "gu"),
+    // 前の文字は見ない。語に続くもの（別表第一第一号）も見つけて、並びの続きを止めるのに使う。
+    bare: vocabulary.inside.length === 0 ? undefined : new RegExp(`(?<suffix>${inside}(?:${suffix})*)${end}`, "gu"),
+    suffix: new RegExp(`${escape(vocabulary.suffixPrefix)}(?<n>${vocabulary.count})(?<unit>${units})`, "gu"),
+    notAfter: vocabulary.notAfter === undefined ? undefined : new RegExp(`(?:${vocabulary.notAfter})$`, "u"),
+    joins: new RegExp(`(?:${[...vocabulary.joiners, ...profile.connectives.map(escape)].join("|") || "(?!)"})`, "gu"),
+    ways: waysOf(vocabulary),
+  };
+};
+
+const compiled = new WeakMap<DocumentProfile, Compiled>();
+
+/** 「第二項第三号」を「2:2,3:3」（深さ:番号）にする。読めない数があれば undefined。 */
+const suffixOf = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): string | undefined => {
+  const parts = [...text.matchAll(patterns.suffix)].map((match) => {
+    const value = number(match.groups?.["n"] ?? "");
+    const depth = vocabulary.units[match.groups?.["unit"] ?? ""];
+    return value === undefined || depth === undefined ? undefined : `${String(depth)}:${String(value)}`;
+  });
+  return parts.includes(undefined) ? undefined : parts.join(",");
+};
+
+/** 「各」は前の全部（0）、数が無ければ 1。 */
+const countOf = (count: string | undefined, vocabulary: RelativeVocabulary, number: NumberReader): number | undefined => {
+  if (count === undefined) return 1;
+  return vocabulary.every.includes(count) ? 0 : number(count);
+};
+
+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[] = [];
+  const opens: number[] = [];
+  characters(text).forEach(({ char, at }) => {
+    if (char === quote.open) opens.push(at);
+    const start = char === quote.close ? opens.pop() : undefined;
+    if (start !== undefined && opens.length === 0) spans.push({ start, end: at + char.length });
+  });
+  return spans;
+};
+
+/** 読み替えの括弧（閉じの直後か開きの直前に目印があるもの）の範囲。 */
+const substitutionSpans = (text: string, quote: Substitution | undefined): Span[] =>
+  quote === undefined
+    ? []
+    : outerQuotes(text, quote).filter(
+        (span) => quote.after.some((marker) => text.startsWith(marker, span.end)) || quote.before.some((marker) => text.slice(0, span.start).endsWith(marker)),
+      );
+
+/** 閉じた括弧書きを内側から外す。 */
+const withoutAsides = (gap: string, aside: RelativeVocabulary["aside"]): string => {
+  if (aside === undefined) return gap;
+  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);
+};
+
+/** あいだが、並びをつなぐもの・つなぎの語・閉じた括弧書き・空白だけか。 */
+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";
+
+/** すぐ前が not_after に当たる（「別表第一」の「一」に続く「第一号」）。 */
+const glued = (text: string, start: number, patterns: Compiled): boolean => patterns.notAfter?.test(text.slice(0, start)) === true;
+
+type Bare = { readonly start: number; readonly end: number; readonly label: string; readonly suffix: string; readonly first: number };
+
+const bareCandidates = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): Bare[] =>
+  patterns.bare === undefined
+    ? []
+    : [...text.matchAll(patterns.bare)].flatMap((match) => {
+        const suffix = suffixOf(match.groups?.["suffix"] ?? "", patterns, vocabulary, number);
+        const first = Number(suffix?.split(":")[0]);
+        return suffix === undefined || !Number.isInteger(first)
+          ? []
+          : [{ start: match.index, end: match.index + match[0].length, label: match[0], suffix, first }];
+      });
+
+/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。 */
+type BareWay = { readonly way: string; readonly continues?: Mention | undefined };
+
+/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。 */
+const wayOfBare = (text: string, bare: Bare, known: readonly Mention[], patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+  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 joined = previous !== undefined && onlyJoins(text.slice(previous.end, bare.start), patterns, vocabulary) ? previous : undefined;
+  const continues = joined ?? ownerOfAside(text, bare.start, known, vocabulary);
+  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 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);
+    // 条を書かない番地は、その一つ上（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 });
+  });
+  return found.filter((mention) => mention.attrs["relative"] !== OPAQUE);
+};
+
+const namedMentions = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): Mention[] =>
+  [...text.matchAll(patterns.named)].flatMap((match) => {
+    const groups = match.groups ?? {};
+    const way = patterns.ways.get(groups["way"] ?? "");
+    const level = vocabulary.units[groups["unit"] ?? ""];
+    const count = countOf(groups["count"], vocabulary, number);
+    const suffix = suffixOf(groups["suffix"] ?? "", patterns, vocabulary, number);
+    if (way === undefined || level === undefined || count === undefined || suffix === undefined) return [];
+    return [{ start: match.index, end: match.index + match[0].length, attrs: { label: match[0], relative: way, level, count, suffix } }];
+  });
+
+/** absolute は同じ行の番地を名指しした参照。条を書かない番地が、その続きかどうかを決めるのに使う。 */
+export const relativeMentions = (
+  text: string,
+  profile: DocumentProfile | undefined,
+  number: NumberReader | undefined,
+  absolute: readonly Mention[] = [],
+): Mention[] => {
+  const vocabulary = profile?.relative;
+  if (profile === undefined || vocabulary === undefined || number === undefined) return [];
+  if (!compiled.has(profile)) compiled.set(profile, compile(profile, vocabulary));
+  const patterns = compiled.get(profile);
+  if (patterns === undefined) return [];
+  const substituted = substitutionSpans(text, vocabulary.substitution);
+  const named = namedMentions(text, patterns, vocabulary, number);
+  const bare = bareMentions(text, patterns, vocabulary, number, [...absolute, ...named]);
+  return [...named, ...bare]
+    .filter((mention) => !substituted.some((span) => span.start <= mention.start && mention.start < span.end))
+    .sort((left, right) => left.start - right.start);
+};

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