chaffjs 0.17.0 → 0.18.0

package/src/markup.ts

@@ -0,0 +1,210 @@
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import { headingText } from "./heading-text.ts";
+import { eachPreOrder } from "./tree-walk.ts";
+import { alertReader } from "./template-syntax.ts";
+import { cutSpans } from "./span-cut.ts";
+import { mergeSpans } from "./span-merge.ts";
+import { firstEndingAfter } from "./soft-break.ts";
+import type { Markup, MarkupHeading, MarkupImage, MarkupLink, Span } from "./plugin.ts";
+
+/** mdast の節のうち、ここで読む値。MarkdownNode の型には無いものを、型を見て取り出す。 */
+const fieldOf = (node: MarkdownNode, field: string): unknown => (field in node ? Reflect.get(node, field) : undefined);
+
+const numberField = (node: MarkdownNode, field: string): number | undefined => {
+  const value = fieldOf(node, field);
+  return typeof value === "number" ? value : undefined;
+};
+
+const stringField = (node: MarkdownNode, field: string): string | undefined => {
+  const value = fieldOf(node, field);
+  return typeof value === "string" ? value : undefined;
+};
+
+// 見出しの末尾に付けた名前。属性（`{#step1 .class}`）と、MDX のコメント（`{/*step1*/}`）。
+type NamedHeading = { readonly text: string; readonly id: string | undefined };
+
+const MDX_COMMENT_OPEN = "/*";
+const MDX_COMMENT_CLOSE = "*/";
+
+/** 見出しの言葉（textOf の結果）から、末尾の名前を外す。名前が無ければ id は undefined。 */
+export const namedHeading = (written: string): NamedHeading => {
+  const trimmed = written.trim();
+  const open = trimmed.lastIndexOf("{");
+  if (!trimmed.endsWith("}") || open === -1) return { text: trimmed, id: undefined };
+  const inner = trimmed.slice(open + 1, -1).trim();
+  const before = trimmed.slice(0, open).trim();
+  if (inner.startsWith("#")) return { text: before, id: inner.slice(1).split(/\s/u)[0] };
+  const isComment = inner.startsWith(MDX_COMMENT_OPEN) && inner.endsWith(MDX_COMMENT_CLOSE);
+  return isComment ? { text: before, id: inner.slice(MDX_COMMENT_OPEN.length, -MDX_COMMENT_CLOSE.length).trim() } : { text: trimmed, id: undefined };
+};
+
+/** HTML の id・name 属性の値。属性の前は空白なので、data-id は数えない。 */
+const HTML_ID = /\s(?:id|name)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/giu;
+
+/** `<img …>`。引用符の中の `>`（title="2 > 1"）では閉じない。 */
+const IMG_TAG = /<img\b(?:"[^"]*"|'[^']*'|[^"'>])*>/giu;
+const ALT_ATTRIBUTE = /\salt\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))?/iu;
+
+/** 中の字が、字のまま見える範囲にならない節。リンクの字はリンクで（中の画像は読む）。 */
+const LINKS = new Set(["link", "linkReference"]);
+
+type Walk = {
+  readonly headings: MarkupHeading[];
+  readonly images: MarkupImage[];
+  readonly links: MarkupLink[];
+  readonly ids: Set<string>;
+  readonly texts: Span[];
+  /** 参照の定義（`[label]: url`）を名前ごとに。使われた定義だけが、読み手の押すリンクになる。 */
+  readonly definitions: Map<string, MarkupLink>;
+  /** 参照の形のリンクと画像が使った名前。 */
+  readonly referenced: Set<string>;
+};
+
+const plainText = (node: MarkdownNode, source: string): string => {
+  const parts: string[] = [];
+  eachPreOrder(node, (child) => {
+    const span = spanOf(child);
+    if ((child.type === "text" || child.type === "inlineCode") && span !== undefined) parts.push(source.slice(span.start, span.end));
+  });
+  return parts.join("");
+};
+
+/** ATX の見出しの閉じの `#`。 */
+const ATX_CLOSING = /\s#+\s*$/u;
+
+/** MDX のコメントの `*` を強調の印として外した後に残る `{/…/}` を外す。 */
+const withoutMdxComment = (text: string): string => {
+  const open = text.lastIndexOf("{/");
+  return text.endsWith("/}") && open !== -1 ? text.slice(0, open).trimEnd() : text;
+};
+
+const firstLineOf = (text: string): string => text.split("\n", 1)[0] ?? "";
+
+const readHeading = (node: MarkdownNode, span: Span, source: string, walk: Walk): void => {
+  // 名前は書いたままの行から読む。MDX のコメントの `*` は、解析すると強調の印になって消える。
+  const { id } = namedHeading(firstLineOf(source.slice(span.start, span.end)).replace(ATX_CLOSING, ""));
+  if (id !== undefined && id !== "") walk.ids.add(id);
+  const text = withoutMdxComment(headingText(plainText(node, source)));
+  walk.headings.push({ depth: numberField(node, "depth") ?? 1, text, start: span.start, end: span.end });
+};
+
+/** 属性の値の文字参照のうち、名前に書かれるもの。ほかの名前の参照は id にまず現れない。 */
+const NAMED_REFERENCES: Readonly<Record<string, string>> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+
+const CHARACTER_REFERENCE = /&(?:#(\d+)|#x([\da-f]+)|([a-z]+));/giu;
+
+const HEX = 16;
+
+/** Unicode の字の番号の上限。 */
+const LAST_CODE_POINT = 0x10ffff;
+
+/** 番号の字。字の番号でなければ（&#999999999;）undefined で、参照は書いたまま残す。 */
+const characterOf = (codePoint: number): string | undefined =>
+  Number.isSafeInteger(codePoint) && codePoint > 0 && codePoint <= LAST_CODE_POINT ? String.fromCodePoint(codePoint) : undefined;
+
+/** 属性の値の文字参照（&amp;、&#38;、&#x26;）を字に戻す。ブラウザが名前として読むのは戻した字。 */
+export const decodedAttribute = (value: string): string =>
+  value.replace(CHARACTER_REFERENCE, (whole: string, decimal?: string, hex?: string, name?: string) => {
+    if (decimal !== undefined) return characterOf(Number(decimal)) ?? whole;
+    if (hex !== undefined) return characterOf(Number.parseInt(hex, HEX)) ?? whole;
+    return NAMED_REFERENCES[(name ?? "").toLowerCase()] ?? whole;
+  });
+
+/** HTML のコメント。中の要素は表示されない。 */
+const HTML_COMMENT = /<!--[\s\S]*?-->/gu;
+
+/** コメントを同じ長さの空白にする。位置は変えない。 */
+const withoutComments = (html: string): string => html.replace(HTML_COMMENT, (comment) => " ".repeat(comment.length));
+
+/** 中身が表示されない要素（`<script>`、`<style>`）で始まる HTML。中の `<img>` や id は字の並びで、ページの要素ではない。 */
+const SOURCE_ELEMENT = /^\s*<(?:script|style)\b/iu;
+
+const readHtml = (written: string, span: Span, walk: Walk): void => {
+  if (SOURCE_ELEMENT.test(written)) return;
+  const value = withoutComments(written);
+  [...value.matchAll(HTML_ID)].forEach((match) => walk.ids.add(decodedAttribute(match[1] ?? match[2] ?? match[3] ?? "")));
+  [...value.matchAll(IMG_TAG)].forEach((match) => {
+    const alt = ALT_ATTRIBUTE.exec(match[0]);
+    const start = span.start + match.index;
+    walk.images.push({ alt: alt === null ? undefined : (alt[1] ?? alt[2] ?? alt[3] ?? ""), start, end: start + match[0].length });
+  });
+};
+
+/** 同じ名前の定義が二つあれば、CommonMark は先のものを使う。後のものは使われない。 */
+const defineOnce = (walk: Walk, name: string, link: MarkupLink): void => {
+  if (!walk.definitions.has(name)) walk.definitions.set(name, link);
+};
+
+/** リンクと参照の定義。定義は、使われたかを最後に見るので別に持つ。 */
+const readLink = (node: MarkdownNode, span: Span, walk: Walk): void => {
+  if (node.type === "link") walk.links.push({ destination: node.url ?? "", ...span });
+  else if (node.type === "definition") defineOnce(walk, node.identifier ?? "", { destination: node.url ?? "", ...span });
+  else if (node.type === "linkReference") walk.referenced.add(node.identifier ?? "");
+};
+
+const LINK_NODES = new Set(["link", "definition", "linkReference"]);
+
+const readNode = (node: MarkdownNode, span: Span, source: string, walk: Walk, inLink: boolean): void => {
+  if (node.type === "heading") readHeading(node, span, source, walk);
+  else if (node.type === "image" || node.type === "imageReference") walk.images.push({ alt: stringField(node, "alt") ?? "", ...span });
+  else if (LINK_NODES.has(node.type)) readLink(node, span, walk);
+  else if (node.type === "html") readHtml(node.value ?? "", span, walk);
+  else if (node.type === "text" && !inLink) walk.texts.push(span);
+};
+
+/** sorted（昇順・重ならない）のどれかの中で始まるか。記法の範囲が何千あっても、節ごとに全部をなめない。 */
+const startsInside = (span: Span, sorted: readonly Span[]): boolean => {
+  const region = sorted[firstEndingAfter(sorted, span.start)];
+  return region !== undefined && region.start <= span.start;
+};
+
+type Pending = { readonly node: MarkdownNode; readonly inLink: boolean };
+
+/**
+ * Markdown の記法の手がかりを集める。outside（メールの引用した返信と、MDX の import やテンプレートの記法）と、
+ * 引用（`>`）の中は読まない。返信と引用はほかの人の文書で、記法は読み手に見えない。
+ * GitHub の注記（`> [!NOTE]`）は書き手の言葉なので読む。本文の組み立て（document.ts）と同じ線引き。
+ */
+export const markdownMarkup = (root: MarkdownNode, source: string, outside: readonly Span[] = []): Markup => {
+  const walk: Walk = { headings: [], images: [], links: [], ids: new Set(), texts: [], definitions: new Map(), referenced: new Set() };
+  const alertOf = alertReader(source);
+  const skipped = mergeSpans(outside, false);
+  const pending: Pending[] = [{ node: root, inLink: false }];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === undefined) break;
+    const { node, inLink } = next;
+    const span = spanOf(node);
+    if (span !== undefined && startsInside(span, skipped)) continue;
+    if (node.type === "blockquote" && alertOf(node) === undefined) continue;
+    if (span !== undefined) readNode(node, span, source, walk, inLink);
+    const childInLink = inLink || LINKS.has(node.type);
+    (node.children ?? []).toReversed().forEach((child) => pending.push({ node: child, inLink: childInLink }));
+  }
+  const { definitions, referenced, ...found } = walk;
+  const used = [...definitions].filter(([name]) => referenced.has(name)).map(([, link]) => link);
+  // 字の節の途中から始まる記法（`{{ … }}`）も、字のまま見える範囲から切り取る。
+  const texts = cutSpans(found.texts, skipped);
+  return { markdown: true, ...found, texts, links: [...found.links, ...used].toSorted((left, right) => left.start - right.start) };
+};
+
+/** Markdown でない文書。記法は無く、文書全体が字のまま見える。 */
+export const plainMarkup = (source: string): Markup => ({
+  markdown: false,
+  headings: [],
+  images: [],
+  links: [],
+  ids: new Set(),
+  texts: [{ start: 0, end: source.length }],
+});
+
+const built = new WeakMap<MarkdownNode, Markup>();
+
+/** 文書の記法を、文書ごとに一度だけ作る。root は文書を解析した木で、文書ごとに一つ。 */
+export const documentMarkup = (root: MarkdownNode, source: string, markdown: boolean, outside: readonly Span[]): Markup => {
+  const cached = built.get(root);
+  if (cached !== undefined) return cached;
+  const markup = markdown ? markdownMarkup(root, source, outside) : plainMarkup(source);
+  built.set(root, markup);
+  return markup;
+};

package/src/mask.ts

@@ -19,12 +19,12 @@ const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " "
 
 export const maskSpans = (source: string, spans: readonly Span[]): string => {
   const merged = mergeSpans(spans, true);
-  const { parts, cursor } = merged.reduce<{ parts: string[]; cursor: number }>(
-    (acc, span) => ({
-      parts: [...acc.parts, source.slice(acc.cursor, span.start), blankOut(source.slice(span.start, span.end))],
-      cursor: span.end,
-    }),
-    { parts: [], cursor: 0 },
-  );
-  return [...parts, source.slice(cursor)].join("");
+  // 部品は配列に足していく。範囲ごとに配列を作り直すと、範囲が何万もある文書で二乗に遅くなる。
+  const parts: string[] = [];
+  const cursor = merged.reduce((at, span) => {
+    parts.push(source.slice(at, span.start), blankOut(source.slice(span.start, span.end)));
+    return span.end;
+  }, 0);
+  parts.push(source.slice(cursor));
+  return parts.join("");
 };

package/src/number-name.ts

@@ -1,4 +1,4 @@
-import { hyphenGroups, isHyphen } from "./orthography.ts";
+import { HYPHEN_CHARS, hyphenGroups, isHyphen } from "./orthography.ts";
 import type { Span, Token } from "./plugin.ts";
 
 /**
@@ -6,8 +6,9 @@ import type { Span, Token } from "./plugin.ts";
  * 「〒100-8916 東京都」の郵便番号、「紀尾井町1-3 東京ガーデンテラス」の番地は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
  * 空け方を数える材料にしない。
  *
- * 形で名前と読むのは五つだけ。0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
- * 文頭の階層つきの節番号（2.1、3.1.2）、続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * 形で名前と読むのは六つだけ。0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
+ * 文頭の階層つきの節番号（2.1、3.1.2）、続き番号になった行や番号の並ぶ箇条書きの頭の番号（白書の注、関連コード）、「問3」のように番号の前に書く語のすぐ後ろの番号。
+ * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
  * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
  * 品詞が無ければ判断せず、名前とは読まない。
  */
@@ -36,12 +37,14 @@ const isHyphenIdentifier = (digits: string): boolean => {
 const DIGIT_OR_POINT = /[\d.]/u;
 const isRunChar = (char: string | undefined): boolean => DIGIT_OR_POINT.test(char ?? "") || isHyphen(char);
 
-/** at を含む、数字・小数点・ハイフン（全角の「－」なども）の並び。at が並びの中に無ければ undefined。 */
+/** at を含む、数字・小数点・ハイフン（全角の「－」なども）の並び。at が並びの中に無ければ undefined。並びは本文ほど長くなれるので、1 字ずつ呼び直さずに進む。 */
 export const digitRunAround = (text: string, at: number): Span | undefined => {
   if (!isRunChar(text[at])) return undefined;
-  const startAt = (index: number): number => (index > 0 && isRunChar(text[index - 1]) ? startAt(index - 1) : index);
-  const endAt = (index: number): number => (index < text.length && isRunChar(text[index]) ? endAt(index + 1) : index);
-  return { start: startAt(at), end: endAt(at) };
+  let start = at;
+  while (start > 0 && isRunChar(text[start - 1])) start -= 1;
+  let end = at;
+  while (end < text.length && isRunChar(text[end])) end += 1;
+  return { start, end };
 };
 
 /** 並びの後ろ（空白 1 つまで）で始まる語。 */
@@ -63,23 +66,123 @@ const CONJUNCTIONS = new Set(["CCONJ", "SCONJ"]);
  */
 const NUMBERED_LINE = /^[ \t]*(?:[-*+][ \t]+)?(?<number>\d{1,3})[ \t]+\S/gmu;
 
-export const sequenceLabelStarts = (text: string): ReadonlySet<number> => {
+const noteSequenceStarts = (text: string): number[] => {
   const lines = [...text.matchAll(NUMBERED_LINE)].map((match) => {
     const number = match.groups?.["number"] ?? "";
     return { start: match.index + match[0].indexOf(number), value: Number(number) };
   });
   const continues = (index: number): boolean =>
     lines[index - 1]?.value === (lines[index]?.value ?? 0) - 1 || lines[index + 1]?.value === (lines[index]?.value ?? 0) + 1;
-  return new Set(lines.flatMap((line, index) => (continues(index) ? [line.start] : [])));
+  return lines.flatMap((line, index) => (continues(index) ? [line.start] : []));
 };
 
+/**
+ * 箇条書きの項目の頭の番号（- 1122 医療費控除…、- 3-1個人情報…）。番号の後ろに「.」を書く番号付きの箇条書き（1. 概要）は、番号が印なので入れない。
+ * 階層は「.」かハイフンでつなぐ。
+ */
+const LIST_ITEM_NUMBER = new RegExp(`^[ \\t]*[-*+][ \\t]+(?<number>\\d+(?:[.${HYPHEN_CHARS}]\\d+)*)(?![\\d.．])`, "gmu");
+const LEVEL_SEPARATOR = new RegExp(`[.${HYPHEN_CHARS}]`, "u");
+
+/** 番号の並び以外で、番号の付いた項目と数える最少の数。二つだけでは「3 言語」「5 ユーザー」のような数量の並びと見分けがつかない。 */
+const MIN_LIST_ITEMS = 3;
+
+/** 階層の無い番号だけの並びを、コードの並びと読む最少の桁。「- 3 ユーザー」「- 5 チーム」「- 8 アカウント」は数量の並び。 */
+const MIN_CODE_DIGITS = 3;
+
+/** コードの並びで、次の項目までに増える数の上限。コードは近い番号を並べ（1122、1124、1126）、数量の並びは飛ぶ（100、200、300）。 */
+const MAX_CODE_STEP = 9;
+
+type ListItem = {
+  readonly start: number;
+  readonly lineStart: number;
+  readonly lineEnd: number;
+  readonly number: string;
+  readonly levels: readonly number[];
+};
+
+const listItems = (text: string): ListItem[] =>
+  [...text.matchAll(LIST_ITEM_NUMBER)].map((match) => {
+    const number = match.groups?.["number"] ?? "";
+    const lineEnd = text.indexOf("\n", match.index);
+    return {
+      start: match.index + match[0].length - number.length,
+      lineStart: match.index,
+      lineEnd: lineEnd === -1 ? text.length : lineEnd,
+      number,
+      levels: number.split(LEVEL_SEPARATOR).map(Number),
+    };
+  });
+
+/** 目次の順で earlier が later より前か（2-19 → 3 → 3-1 → 3-1-1）。 */
+const comesBefore = (earlier: readonly number[], later: readonly number[]): boolean => {
+  const differs = earlier.findIndex((level, index) => level !== later[index]);
+  if (differs === -1) return earlier.length < later.length;
+  return (earlier[differs] ?? 0) < (later[differs] ?? -1);
+};
+
+/** 空行だけを挟んで次の項目が続き、番号が増えているか。 */
+const followsItem = (text: string, previous: ListItem, item: ListItem): boolean =>
+  text.slice(previous.lineEnd, item.lineStart).trim() === "" && comesBefore(previous.levels, item.levels);
+
+/**
+ * 前の項目と同じ見出しの下に次の番号が続くか（3 → 3-1、2-18 → 2-19）。並びの番号は増えていくので、頭が同じなら後ろは段を持つ。
+ * 「5 → 8-10」は範囲で、目次の段ではない。
+ */
+const isOutlineStep = (previous: ListItem | undefined, item: ListItem): boolean => previous !== undefined && previous.levels[0] === item.levels[0];
+
+/** 同じ桁数（MIN_CODE_DIGITS 以上）で、MAX_CODE_STEP までずつ増えていくコードの並び（1122、1124、1126）。 */
+const isCodeRun = (run: readonly ListItem[]): boolean => {
+  const width = run[0]?.number.length ?? 0;
+  const closeToPrevious = (item: ListItem, index: number): boolean => index === 0 || (item.levels[0] ?? 0) - (run[index - 1]?.levels[0] ?? 0) <= MAX_CODE_STEP;
+  return width >= MIN_CODE_DIGITS && run.every((item, index) => item.number.length === width && closeToPrevious(item, index));
+};
+
+/**
+ * 番号の並びとして読める項目の並び。目次の段を含む並び（2-19、3、3-1）か、コードの並び（1122、1124）。
+ * 階層の無い数が増えていくだけの並び（3、5、8 や 100、200、300）は、数量を並べたものと見分けがつかない。
+ */
+const isLabelRun = (run: readonly ListItem[]): boolean =>
+  run.length >= MIN_LIST_ITEMS && (run.some((item, index) => isOutlineStep(run[index - 1], item)) || isCodeRun(run));
+
+/**
+ * 箇条書きの項目の頭に番号を置き、下へ番号が増えていく並び（国税庁の関連コード 1122、1124、…、ガイドラインの目次 2-19、3、3-1）。
+ * 番号は飛んでもよいが、isLabelRun の並びだけを番号と読む。
+ */
+const numberedListStarts = (text: string): number[] =>
+  listItems(text)
+    .reduce<ListItem[][]>((runs, item) => {
+      const run = runs.at(-1);
+      const previous = run?.at(-1);
+      if (run !== undefined && previous !== undefined && followsItem(text, previous, item)) run.push(item);
+      else runs.push([item]);
+      return runs;
+    }, [])
+    .filter(isLabelRun)
+    .flatMap((run) => run.map((item) => item.start));
+
+export const sequenceLabelStarts = (text: string): ReadonlySet<number> => new Set([...noteSequenceStarts(text), ...numberedListStarts(text)]);
+
 const isGeoUnit = (token: Token): boolean => token.features?.["NameType"] === "GeoUnit";
 const isPlaceWord = (token: Token): boolean => isGeoUnit(token) || token.features?.["NameType"] === "Geo";
 
-/** end で終わる、間を空けずに続く地名と地名の単位（東京都千代田区紀尾井町）。近いほうから。 */
+/** 終わりの位置ごとの、その位置で終わる最初の地名の語。Map は NaN を NaN の鍵で引けるが、位置の NaN はどこにも等しくないので入れない。 */
+const placesByEnd = (tokens: readonly Token[]): ReadonlyMap<number, Token> => {
+  const byEnd = new Map<number, Token>();
+  tokens.forEach((token) => {
+    if (isPlaceWord(token) && !Number.isNaN(token.span.end) && !byEnd.has(token.span.end)) byEnd.set(token.span.end, token);
+  });
+  return byEnd;
+};
+
+/**
+ * end で終わる、間を空けずに続く地名と地名の単位（東京都千代田区紀尾井町）。近いほうから。
+ * 連なりは本文ほど長くなれるので、語を 1 度だけ読む。同じ語に戻れば（幅の無い語。adapter が壊れているとき）そこで止める。
+ */
 export const placeChainBefore = (tokens: readonly Token[], end: number): Token[] => {
-  const last = tokens.find((token) => token.span.end === end && isPlaceWord(token));
-  return last === undefined ? [] : [last, ...placeChainBefore(tokens, last.span.start)];
+  const byEnd = placesByEnd(tokens);
+  const chain = new Set<Token>();
+  for (let last = byEnd.get(end); last !== undefined && !chain.has(last); last = byEnd.get(last.span.start)) chain.add(last);
+  return [...chain];
 };
 
 /**
@@ -97,22 +200,46 @@ const isNameShaped = (text: string, run: Span): boolean => {
   return isHyphenIdentifier(digits) || LABEL_LEAD.test(before) || (LINE_HEAD.test(before) && SECTION_NUMBER.test(digits));
 };
 
+/** 「問3」「図2」: 番号のすぐ前（空白を挟まない）の語が、番号の前に書いて名前を付ける語。「質問3」の「問」は語ではない。 */
+const followsLabelWord = (run: Span, tokens: readonly Token[], base: number, labelWords: ReadonlySet<string>): boolean =>
+  tokens.some((token) => token.span.end === base + run.start && labelWords.has(token.surface));
+
+/**
+ * 文書全体で一度だけ読むもの。sequence は sequenceLabelStarts の結果、topUnits は都道府県の単位、
+ * labelWords は番号の前に書いて名前を付ける語（語彙表 numbered-label の before）。
+ */
+export type NameContext = {
+  readonly sequence?: ReadonlySet<number>;
+  readonly topUnits?: ReadonlySet<string>;
+  readonly labelWords?: ReadonlySet<string>;
+};
+
 /**
- * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果、
- * topUnits は都道府県の単位。
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。
  * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
  */
-export const isNumberName = (
-  text: string,
-  run: Span,
-  tokens: readonly Token[] | undefined,
-  base: number,
-  sequence: ReadonlySet<number> = new Set(),
-  topUnits: ReadonlySet<string> = new Set(),
-): boolean => {
-  const inSequence = sequence.has(base + run.start);
-  if (tokens === undefined || !(inSequence || isNameShaped(text, run) || isAddressNumber(text, run, tokens, base, topUnits))) return false;
+export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number, context: NameContext = {}): boolean => {
+  const inSequence = context.sequence?.has(base + run.start) ?? false;
+  if (tokens === undefined) return false;
+  const shaped =
+    inSequence ||
+    isNameShaped(text, run) ||
+    isAddressNumber(text, run, tokens, base, context.topUnits ?? new Set()) ||
+    followsLabelWord(run, tokens, base, context.labelWords ?? new Set());
+  if (!shaped) return false;
   const next = wordAfter(tokens, text, run, base);
   if (next === undefined) return false;
   return !isBoundToNumber(next) || (inSequence && CONJUNCTIONS.has(next.pos));
 };
+
+/** 「第」と番号の後ろに書く区切りの語（第1節、第 2 章）。 */
+const DIVISION_LABEL = /第 ?\d+ ?(?<unit>[^\s\d第]+)$/u;
+
+/**
+ * before が「第1節」「第4章第2節」のように、「第」と番号と区切りの語（語彙表 numbered-label の after）で終わるか。
+ * その後ろの空白は題との区切りで、空け方の好みではない（第1節 AI の…）。
+ */
+export const endsWithDivisionLabel = (before: string, units: ReadonlySet<string>): boolean => {
+  const unit = DIVISION_LABEL.exec(before)?.groups?.["unit"];
+  return unit !== undefined && units.has(unit);
+};

package/src/orthography.ts

@@ -140,7 +140,9 @@ const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
 const MIN_CODE_GROUPS = 3;
 
 // 通達の「5－1－1」は全角の「－」でつなぐ。ハイフン「‐」やマイナス「−」も同じに読む。長音「ー」は仮名の一部なので入れない。
-const HYPHEN = /[-‐‑−－]/u;
+/** 正規表現の文字クラスに入れるハイフンの字。- は範囲の記号にならないよう \ を付ける。 */
+export const HYPHEN_CHARS = "\\-‐‑−－";
+const HYPHEN = new RegExp(`[${HYPHEN_CHARS}]`, "u");
 
 /** 数字をつなぐハイフンか。半角の - のほか、全角・和文のハイフンも。 */
 export const isHyphen = (char: string | undefined): boolean => char !== undefined && HYPHEN.test(char);
@@ -166,8 +168,7 @@ const isUncountedNumber = (chars: readonly string[], index: number): boolean =>
   return left === ORDINAL_PREFIX || (isJapanese(left) && isCode(chars, next));
 };
 
-const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
-  if (isUncountedNumber(chars, index)) return undefined;
+const candidateAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
   const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
   const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
   if (touching !== undefined) return { kind: touching, spaced: false };
@@ -176,6 +177,12 @@ const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "of
   return spaced === undefined ? undefined : { kind: spaced, spaced: true };
 };
 
+// isUncountedNumber は数字の並びを端まで読む。境目の候補でだけ聞けば、並びの字ごとではなく並びごとに一度で済む。
+const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  const candidate = candidateAt(chars, index);
+  return candidate === undefined || isUncountedNumber(chars, index) ? undefined : candidate;
+};
+
 /**
  * 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。
  * text は本文でないものを空白で覆った文、written は覆う前の同じ範囲。覆ってできた空白（リンクの「[」など）は

package/src/page-furniture.ts

@@ -1,5 +1,7 @@
 import type { Span } from "./plugin.ts";
 import { NO_OUTLINE, type Outline } from "./structure/build.ts";
+import { markdownFigures, textFigures } from "./text-figures.ts";
+import type { MarkdownNode } from "./markdown-node.ts";
 
 /** 改ページから、飾りの行を探しにいく行数。飾りと改ページのあいだには空行が数行入る。 */
 const REACH = 3;
@@ -41,5 +43,12 @@ export const pageFurniture = (source: string): Span[] => {
   });
 };
 
-/** テキストの文書の外形。見出しもコードも無く、ページの飾りだけを覆う。木を作る入口はどれもこれを使う。 */
-export const textOutline = (source: string): Outline => ({ ...NO_OUTLINE, opaque: pageFurniture(source) });
+/** テキストの文書の外形。見出しもコードも無く、ページの飾り・線で描いた図・メールの引用した返信だけを覆う。木を作る入口はどれもこれを使う。 */
+export const textOutline = (source: string, replyQuotes: readonly Span[] = []): Outline => ({
+  ...NO_OUTLINE,
+  opaque: [...pageFurniture(source), ...textFigures(source), ...replyQuotes],
+});
+
+/** 紙面の形で本文でないもの: テキストの文書のページの飾り（Markdown には改ページが無い）と、線で描いた図。 */
+export const layoutMasks = (root: MarkdownNode, source: string, markdown: boolean): Span[] =>
+  markdown ? markdownFigures(root, source) : [...pageFurniture(source), ...textFigures(source)];

package/src/plain-source.ts

@@ -1,5 +1,6 @@
 /**
  * The Markdown parser drops a leading BOM and reads a lone "\r" as a line break; the rest of chaff counts "\n" only.
  * Reading the file this way keeps every offset, line and column on the text the writer sees.
+ * Every leading BOM goes, so that running this twice (on reading, then in buildDocument) gives the same text as once.
  */
-export const plainSource = (raw: string): string => raw.replace(/^\uFEFF/u, "").replace(/\r\n?/gu, "\n");
+export const plainSource = (raw: string): string => raw.replace(/^\uFEFF+/u, "").replace(/\r\n?/gu, "\n");