chaffjs 0.16.0 → 0.18.0

package/src/long-vowel.ts

@@ -0,0 +1,99 @@
+// The final long-vowel mark (ー) of katakana loanwords: how long a word is, and which written forms go against the chosen way.
+// Pure: the words come in already picked from the document's tokens.
+
+/** Small kana that join the kana before them into one mora (キャ, ファ, ウィ). ッ, ン and ー are morae of their own. */
+const JOINING: ReadonlySet<string> = new Set(Array.from("ァィゥェォャュョヮぁぃぅぇぉゃゅょゎ"));
+
+/** The number of morae (音) in a kana word: コンピューター is コ・ン・ピュ・ー・タ・ー, six. */
+export const moraCount = (word: string): number => Array.from(word).filter((char) => !JOINING.has(char)).length;
+
+const LONG_VOWEL = "ー";
+const KATAKANA_WORD = /^[ァ-ヺー]+$/u;
+
+/** A katakana word without its final ー: the part both ways of writing it share (コンピュータ for コンピューター). */
+export const stemOf = (surface: string): string => {
+  const chars = Array.from(surface);
+  return chars.slice(0, chars.findLastIndex((char) => char !== LONG_VOWEL) + 1).join("");
+};
+
+/** Whether the surface is a katakana word with something besides ー in it. */
+export const isKatakanaWord = (surface: string): boolean => KATAKANA_WORD.test(surface) && stemOf(surface) !== "";
+
+/** A katakana word the rule reads: where it is, how it is written, and whether a final ー could be written or dropped. */
+export type KanaWord = {
+  readonly surface: string;
+  readonly offset: number;
+  /** Written with a final ー. */
+  readonly long: boolean;
+  /** Written without one, and the dictionary knows the form with one (the language adapter's LongVowelEnding=Dropped). */
+  readonly dropped: boolean;
+};
+
+/** The morae of the word written with its final ー: カー is two, コンピューター six. The guidelines count the word that way. */
+export const longFormMorae = (surface: string): number => moraCount(stemOf(surface)) + 1;
+
+export type Ending = "consistent" | "drop" | "keep";
+
+export type Odd = {
+  readonly word: KanaWord;
+  /** How the rule found it: same-word (one word written both ways), drop or keep (against the setting). */
+  readonly variant: "same-word" | "drop" | "keep";
+  /** The form the rule asks for. */
+  readonly preferred: string;
+  /** For same-word: how many times the word is written the way this one is, and how many times in all. */
+  readonly count: number;
+  readonly of: number;
+};
+
+const otherForm = (word: KanaWord): string => (word.long ? stemOf(word.surface) : `${word.surface}${LONG_VOWEL}`);
+
+/** The side written less; on a tie, the side the document did not use first. undefined when only one side is used. */
+const minorityLong = (words: readonly KanaWord[]): boolean | undefined => {
+  const long = words.filter((word) => word.long).length;
+  const short = words.length - long;
+  if (long === 0 || short === 0) return undefined;
+  if (long !== short) return long < short;
+  return !(words[0]?.long ?? false);
+};
+
+const minorityOf = (words: readonly KanaWord[], variant: Odd["variant"]): Odd[] => {
+  const minority = minorityLong(words);
+  if (minority === undefined) return [];
+  const odd = words.filter((word) => word.long === minority);
+  return odd.map((word) => ({ word, variant, preferred: otherForm(word), count: odd.length, of: words.length }));
+};
+
+/** The document's words grouped by the part both ways share (コンピュータ with コンピューター). */
+const sameWordGroups = (words: readonly KanaWord[]): KanaWord[][] => {
+  const groups = new Map<string, KanaWord[]>();
+  words.forEach((word) => {
+    const stem = stemOf(word.surface);
+    const group = groups.get(stem);
+    if (group === undefined) groups.set(stem, [word]);
+    else group.push(word);
+  });
+  return [...groups.values()];
+};
+
+/**
+ * With no side taken: a word written both ways (コンピュータ and コンピューター), at its fewer form. Different words are not compared:
+ * a document may write サーバー and ブラウザ by each word's usual spelling, and no guideline makes that a mistake.
+ */
+const inconsistent = (words: readonly KanaWord[]): Odd[] => sameWordGroups(words).flatMap((group) => minorityOf(group, "same-word"));
+
+/**
+ * The words that go against the chosen way. drop: a word of minMorae or more written with its final ー. keep: a word written
+ * without one where the dictionary, or the document itself, has the form with one. consistent: see inconsistent.
+ * Words shorter than minMorae are left alone whichever way: the guidelines that drop the ー keep it on them (カー).
+ */
+export const oddLongVowels = (words: readonly KanaWord[], ending: Ending, minMorae: number): Odd[] => {
+  const counted = words.filter((word) => longFormMorae(word.surface) >= minMorae);
+  if (ending === "drop") return counted.filter((word) => word.long).map((word) => ({ word, variant: "drop", preferred: otherForm(word), count: 0, of: 0 }));
+  if (ending === "keep") {
+    const longStems = new Set(counted.filter((word) => word.long).map((word) => stemOf(word.surface)));
+    return counted
+      .filter((word) => !word.long && (word.dropped || longStems.has(word.surface)))
+      .map((word) => ({ word, variant: "keep", preferred: otherForm(word), count: 0, of: 0 }));
+  }
+  return inconsistent(counted).toSorted((left, right) => left.word.offset - right.word.offset);
+};

package/src/markdown-node.ts

@@ -0,0 +1,19 @@
+import type { Span } from "./plugin.ts";
+
+type Place = { readonly offset?: number | undefined };
+
+/** The part of an mdast node chaff reads. */
+export type MarkdownNode = {
+  readonly type: string;
+  readonly url?: string | undefined;
+  readonly value?: string | undefined;
+  readonly identifier?: string | undefined;
+  readonly position?: { readonly start: Place; readonly end: Place } | undefined;
+  readonly children?: readonly MarkdownNode[] | undefined;
+};
+
+export const spanOf = (node: MarkdownNode): Span | undefined => {
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  return start === undefined || end === undefined ? undefined : { start, end };
+};

package/src/markdown-read.ts

@@ -0,0 +1,44 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmTable } from "micromark-extension-gfm-table";
+import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { maskSpans } from "./mask.ts";
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import { componentLines, moduleBlocks, templateSpans } from "./template-syntax.ts";
+import { eachPreOrder } from "./tree-walk.ts";
+import type { Span } from "./plugin.ts";
+
+export const parse = (source: string): MarkdownNode =>
+  fromMarkdown(source, { extensions: [gfmTable(), frontmatter(["yaml"])], mdastExtensions: [gfmTableFromMarkdown(), frontmatterFromMarkdown(["yaml"])] });
+
+export const spansOfType = (root: MarkdownNode, type: string, keep: (node: MarkdownNode) => boolean = () => true): Span[] => {
+  const found: Span[] = [];
+  eachPreOrder(root, (node) => {
+    if (node.type !== type || !keep(node)) return;
+    const span = spanOf(node);
+    if (span !== undefined) found.push(span);
+  });
+  return found;
+};
+
+/** 番号を探してはいけない範囲。コードの中の「第3条」は条ではなく、参照でもない。 */
+const OPAQUE = ["code", "inlineCode", "html", "yaml", "toml"];
+
+export const opaqueSpans = (root: MarkdownNode): Span[] => OPAQUE.flatMap((type) => spansOfType(root, type));
+
+/** Template syntax outside code: a `{{` in backticks is code, and does not open a tag that runs to the next `}}`. */
+const templateOf = (root: MarkdownNode, source: string): Span[] => (source.includes("{") ? templateSpans(maskSpans(source, opaqueSpans(root))) : []);
+
+type MarkdownRead = { readonly root: MarkdownNode; readonly syntax: readonly Span[] };
+
+/**
+ * Markdown as MDX reads it: a line of nothing but JSX tags is a block of its own, not the start of an HTML block.
+ * `syntax` is the site generator's markup in it (those lines, MDX's imports and exports, and template tags outside
+ * code), which is neither prose nor structure.
+ */
+export const readMarkdown = (source: string): MarkdownRead => {
+  const components = source.includes("<") ? componentLines(source) : [];
+  const root = parse(components.length === 0 ? source : maskSpans(source, components));
+  return { root, syntax: [...components, ...moduleBlocks(root, source), ...templateOf(root, source)] };
+};

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

@@ -1,4 +1,5 @@
 import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
 
 /**
  * 非 prose（コードブロック・インラインコード・表・見出し・URL）を、
@@ -16,24 +17,14 @@ import type { Span } from "./plugin.ts";
  */
 const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
-const merge = (spans: readonly Span[]): Span[] =>
-  spans
-    .toSorted((left, right) => left.start - right.start)
-    .reduce<Span[]>((acc, span) => {
-      const last = acc.at(-1);
-      if (last !== undefined && span.start <= last.end) acc[acc.length - 1] = { start: last.start, end: Math.max(last.end, span.end) };
-      else acc.push(span);
-      return acc;
-    }, []);
-
 export const maskSpans = (source: string, spans: readonly Span[]): string => {
-  const merged = merge(spans);
-  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 merged = mergeSpans(spans, true);
+  // 部品は配列に足していく。範囲ごとに配列を作り直すと、範囲が何万もある文書で二乗に遅くなる。
+  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];
 };
 
 /**
@@ -88,7 +191,7 @@ export const placeChainBefore = (tokens: readonly Token[], end: number): Token[]
  * ハイフンの無い数（千代田区23 番）も読まない。topUnits は都道府県の単位（語彙表 prefecture-unit）。
  */
 const isAddressNumber = (text: string, run: Span, tokens: readonly Token[], base: number, topUnits: ReadonlySet<string>): boolean =>
-  [...text.slice(run.start, run.end)].some(isHyphen) &&
+  Array.from(text.slice(run.start, run.end)).some(isHyphen) &&
   placeChainBefore(tokens, base + run.start).some((token) => isGeoUnit(token) && !topUnits.has(token.surface));
 
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
@@ -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);
+};