chaffjs 0.21.0 → 0.22.0

package/src/detectors/relative-pronoun-mix.ts

@@ -0,0 +1,79 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { minorityOf } from "./technical-docs.ts";
+import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
+
+/**
+ * 限定の関係節を which で書く所と that で書く所が、一つの文書に混ざっている所（the file which contains / the file that contains）。
+ * どちらが正しいかは決めず、少ないほうを指す。読むのは「名詞 + which|that + 動詞」の、読点を挟まない形だけ。
+ * that の後ろに主語が来る形（the fact that it works）は、関係節か同格の節か語の並びで決まらないので数えない。
+ */
+
+export type RelativeUse = { readonly word: Token; readonly kind: string };
+
+/** 多いほうの書き方が、文書の書き方と言えるだけの数。 */
+const MIN_USUAL = 3;
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** 解析器は三人称の動詞を複数の名詞と読むことがある（the script that checks links の checks）。 */
+const isThirdPersonVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+const isTaggedFiniteVerb = (token: Token | undefined): boolean =>
+  token !== undefined && VERBAL.has(token.pos) && token.features?.["VerbForm"] !== "Part" && token.features?.["VerbForm"] !== "Ger";
+
+/**
+ * 動詞と読める語。名詞と読まれた三人称の動詞は、後ろに動詞が無いときだけ（the idea that results matter の results は主語）。
+ */
+const isFiniteVerb = (token: Token | undefined, next: Token | undefined): boolean =>
+  isTaggedFiniteVerb(token) || (token !== undefined && isThirdPersonVerb(token) && !isTaggedFiniteVerb(next));
+
+const isBaseForm = (verb: Token): boolean => verb.pos === "VERB" && verb.lemma?.toLowerCase() === verb.surface.toLowerCase();
+
+/**
+ * 名詞の後ろの関係節の動詞。原形の動詞は複数の名詞にだけ続く（resources which set）。単数の名詞の後ろの原形は、
+ * 関係節ではなく「どの」の which（tells the command which file to use）。
+ */
+const opensRelative = (noun: Token | undefined, verb: Token | undefined, next: Token | undefined): boolean =>
+  noun?.pos === "NOUN" && verb !== undefined && isFiniteVerb(verb, next) && (!isBaseForm(verb) || noun.features?.["Number"] === "Plur");
+
+/** which / that の後ろの、副詞を飛ばした最初の語（the file which usually stores の stores）。 */
+const verbAfter = (tokens: readonly Token[], at: number): number => {
+  const found = tokens.findIndex((token, index) => index > at && token.pos !== "ADV");
+  return found === -1 ? tokens.length : found;
+};
+
+/** 語彙表の組（which / that）で、tokens の中の限定の関係節の頭。 */
+export const relativeUses = (tokens: readonly Token[], kinds: Lexicon): RelativeUse[] =>
+  tokens.flatMap((word, at) => {
+    const entry = kinds.find((candidate) => candidate.pattern.toLowerCase() === word.surface.toLowerCase());
+    const verb = verbAfter(tokens, at);
+    if (entry?.group === undefined || !opensRelative(tokens[at - 1], tokens[verb], tokens[verb + 1])) return [];
+    return [{ word, kind: entry.group }];
+  });
+
+/** 二通りの書き方のうち少ないほう。多いほうが MIN_USUAL に満たなければ、文書の書き方と言えないので空。 */
+export const oddRelatives = (uses: readonly RelativeUse[], limit: number): { readonly odd: readonly RelativeUse[]; readonly usual: string } => {
+  const kinds = [...new Set(uses.map((use) => use.kind))];
+  const [first, second] = kinds.map((kind) => uses.filter((use) => use.kind === kind));
+  if (kinds.length !== 2 || first === undefined || second === undefined) return { odd: [], usual: "" };
+  const odd = minorityOf(first, second, limit);
+  const usual = odd === first ? second : first;
+  return usual.length < MIN_USUAL ? { odd: [], usual: "" } : { odd, usual: usual[0]?.word.surface.toLowerCase() ?? "" };
+};
+
+export const relativePronounMix: Detector = (doc, options): Finding[] => {
+  const kinds = doc.lexicons["restrictive-relative"] ?? [];
+  const uses = doc.sentences.flatMap((sentence) => {
+    if (sentence.embeddedLanguage !== undefined) return [];
+    const quoted = quotedIn(sentence, QUOTATION_MARKS);
+    return relativeUses(sentence.tokens ?? [], kinds).filter((use) => !isWithinAny(quoted, use.word.span));
+  });
+  const { odd, usual } = oddRelatives(uses, options.limit);
+  return odd.map((use) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: doc.sentences.find((sentence) => sentence.span.start <= use.word.span.start && use.word.span.start < sentence.span.end)?.text.trim() ?? "",
+    values: { word: use.word.surface, usual, count: odd.length, limit: options.limit, offset: use.word.span.start },
+  }));
+};

package/src/detectors/share-over-hundred.ts

@@ -0,0 +1,75 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 集まりの一部の割合なのに 100% を超える百分率（回答者の120%、150% of respondents）。一部は全体を超えない。
+// 集まりの語は語彙表 share-whole、百分率とのあいだの語とその側は share-whole-link、百分率の単位は percent-unit が言う。
+
+export type ShareWords = {
+  readonly wholes: readonly string[];
+  readonly links: readonly { readonly pattern: string; readonly position: "before" | "after" }[];
+  readonly units: readonly string[];
+};
+
+/** 100% を超える一部の割合 1 つ。written は百分率、whole は何の一部か。 */
+export type ShareOverHundred = { readonly offset: number; readonly end: number; readonly written: string; readonly whole: string };
+
+const WHOLE_PERCENT = 100;
+/** 集まりの語が、より長い語の頭でないこと（users_2025、回答者数）。漢字やカタカナが続けば別の語（回答者数は人数で、割合の元ではない）。 */
+const NOT_INSIDE_WORD = "(?![A-Za-z0-9_\\p{Script=Han}\\p{Script=Katakana}])";
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９．]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/** 集まりの語の前後の英字だけを語の切れ目に見る。日本語は語を続けて書く（アンケートでは回答者の、120%の回答者が）。 */
+const wholeNear = (text: string, start: number, end: number, words: ShareWords): string | undefined => {
+  const wholes = alternation(words.wholes);
+  return words.links
+    .map((link) => {
+      const near =
+        link.position === "after"
+          ? new RegExp(`^\\s*${escapeRegExp(link.pattern)}\\s*(?<whole>${wholes})${NOT_INSIDE_WORD}`, "u").exec(text.slice(end))
+          : new RegExp(`(?<![A-Za-z])(?<whole>${wholes})${escapeRegExp(link.pattern)}\\s*$`, "u").exec(text.slice(0, start));
+      return near?.groups?.["whole"];
+    })
+    .find((whole) => whole !== undefined);
+};
+
+/** 文字列の中の、集まりの一部の割合なのに 100% を超える百分率。 */
+export const sharesOverHundred = (text: string, words: ShareWords): ShareOverHundred[] => {
+  if (words.wholes.length === 0 || words.units.length === 0) return [];
+  const percent = new RegExp(`(?<![\\d.,，０-９])(?<value>[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?)\\s?(?:${alternation(words.units)})`, "gu");
+  return [...text.matchAll(percent)].flatMap((match) => {
+    const value = Number(halfWidth(match.groups?.["value"] ?? "").replace(/[,，]/gu, ""));
+    if (value <= WHOLE_PERCENT) return [];
+    const end = match.index + match[0].length;
+    const whole = wholeNear(text, match.index, end, words);
+    return whole === undefined ? [] : [{ offset: match.index, end, written: match[0], whole }];
+  });
+};
+
+const positioned = (doc: ProseDocument): ShareWords["links"] =>
+  (doc.lexicons["share-whole-link"] ?? []).flatMap((entry) => (entry.position === undefined ? [] : [{ pattern: entry.pattern, position: entry.position }]));
+
+export const shareOverHundred: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const words: ShareWords = {
+    wholes: (doc.lexicons["share-whole"] ?? []).map((entry) => entry.pattern),
+    links: positioned(doc),
+    units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  };
+  return sharesOverHundred(text, words).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.end),
+    values: { written: found.written, whole: found.whole, offset: found.offset },
+  }));
+};

package/src/detectors/step-reference.ts

@@ -0,0 +1,83 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 本文が指す手順の番号（「手順5を参照」「see step 5」）が、文書のどの手順にも無い所。
+// 手順は、手順の語（語彙表 step-word）と番号で始まる見出しと、番号付きの箇条書きの項目。手順が一つも無い文書では言わない。
+// 番号のすぐ後ろの語（語彙表 figure-elsewhere の of・in）や前の文書の名前が、ほかの文書の手順だと言えば数えない。
+
+/** 無い手順を指す参照 1 つ。label は書いたままの参照、last は文書の手順の最後の番号。 */
+export type MissingStep = { readonly offset: number; readonly label: string; readonly last: number };
+
+/**
+ * 手順を読むのに要るもの。source は見出しの印（#）を残した文書、prose はコードを覆った本文（位置は source と同じ）。
+ * elsewhere は参照がほかの文書の手順を指すか（参照の始まりと終わりの位置で）。
+ */
+export type StepText = { readonly source: string; readonly prose: string; readonly elsewhere: (start: number, end: number) => boolean };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const LIST_ITEM = /^[ \t]*(?<number>\d{1,3})[.)][ \t]/u;
+const HEADING = /^#{1,6}[ \t]+/u;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+type Mention = { readonly offset: number; readonly label: string; readonly number: number; readonly heading: boolean };
+
+const mentionPattern = (words: readonly string[]): RegExp =>
+  new RegExp(`(?<![A-Za-z])(?:${words.map(escapeRegExp).join("|")})[ \\t\\u3000]?(?<number>[0-9０-９]{1,3})(?![0-9０-９A-Za-z])`, "gu");
+
+const isHeadingAt = (source: string, offset: number): boolean => HEADING.test(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset));
+
+/** 本文の参照（コードを覆った prose から）と、見出しの手順（prose は見出しも覆うので source から）。 */
+const mentionsOf = ({ source, prose }: StepText, words: readonly string[]): Mention[] => {
+  const toMention = (match: RegExpExecArray | RegExpMatchArray, heading: boolean): Mention => ({
+    offset: match.index ?? 0,
+    label: match[0],
+    number: Number(halfWidth(match.groups?.["number"] ?? "")),
+    heading,
+  });
+  const headings = [...source.matchAll(mentionPattern(words))].filter((match) => isHeadingAt(source, match.index)).map((match) => toMention(match, true));
+  const references = [...prose.matchAll(mentionPattern(words))].filter((match) => !isHeadingAt(source, match.index)).map((match) => toMention(match, false));
+  return [...headings, ...references];
+};
+
+const listNumbers = (prose: string): number[] =>
+  prose.split("\n").flatMap((line) => {
+    const number = LIST_ITEM.exec(line)?.groups?.["number"];
+    return number === undefined ? [] : [Number(number)];
+  });
+
+/** 文書のどの手順にも無い番号を指す参照。手順の最後の番号を超えるものだけ（箇条書きが二つあれば、番号はどちらかにある）。 */
+export const missingSteps = (text: StepText, words: readonly string[]): MissingStep[] => {
+  if (words.length === 0) return [];
+  const mentions = mentionsOf(text, words);
+  const steps = [...mentions.filter((mention) => mention.heading).map((mention) => mention.number), ...listNumbers(text.prose)];
+  if (steps.length === 0) return [];
+  const last = Math.max(...steps);
+  return mentions
+    .filter((mention) => !mention.heading && mention.number > last && !text.elsewhere(mention.offset, mention.offset + mention.label.length))
+    .map((mention) => ({ offset: mention.offset, label: mention.label, last }));
+};
+
+/** 番号のすぐ後ろが figure-elsewhere の語か、すぐ前がこの文書でない文書の名前なら、ほかの文書の手順。 */
+const elsewhereOf =
+  (doc: ProseDocument, text: string) =>
+  (start: number, end: number): boolean => {
+    const after = text.slice(end).trimStart();
+    const placed = (doc.lexicons["figure-elsewhere"] ?? []).some((entry) => after.startsWith(`${entry.pattern} `) && /^\s/u.test(text.slice(end)));
+    const named = doc.namedDocument?.(text, start);
+    return placed || (named !== undefined && !named.self);
+  };
+
+export const stepReference: Detector = (doc): Finding[] => {
+  const prose = doc.prose ?? doc.source;
+  const words = (doc.lexicons["step-word"] ?? []).map((entry) => entry.pattern);
+  return missingSteps({ source: doc.source, prose, elsewhere: elsewhereOf(doc, prose) }, words).map((missing) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(prose, missing.offset, missing.offset + missing.label.length),
+    values: { label: missing.label, last: missing.last, offset: missing.offset },
+  }));
+};

package/src/detectors/toc-heading.ts

@@ -0,0 +1,125 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { headingWords } from "../structure-shape/heading-words.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 目次の項目が、文書のどの見出しとも合わない所。目次の見出しは語彙表 toc-heading が言う。
+// 項目と見出しは、空白・記号・大文字小文字を無視して比べ、頭の番号（1.2、2-1、第3章）を外しても比べる。
+
+/** 見出しの無い目次の項目 1 つ。entry は項目の言葉（リンクなら字の部分）。 */
+export type StrayTocEntry = { readonly offset: number; readonly entry: string };
+
+type Line = { readonly text: string; readonly offset: number };
+type Heading = { readonly title: string; readonly offset: number };
+
+const HEADING = /^[ \t]{0,3}#{1,6}[ \t]/u;
+const FENCE = /^[ \t]*(?:```|~~~)/u;
+const LIST_ITEM = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+const LINK_TEXT = /^\[(?<text>[^\]]*)\]\([^)]*\)/u;
+const ATTRIBUTES = /\{#[^}]*\}/gu;
+const DIGIT = /[\d０-９]/u;
+const LEADER_DOTS = new Set([".", "…", "・"]);
+const MIN_LEADER = 2;
+/** 目次の項目のうち見出しに合わないものがこれより多ければ、目次は別の書き方の見出し（本文に無い章立て）と読んで言わない。 */
+const MAX_STRAY_SHARE = 0.5;
+
+const linesOf = (source: string): Line[] => [...source.matchAll(/^.*$/gmu)].map((match) => ({ text: match[0], offset: match.index }));
+
+/** コードの囲みの外の行。 */
+const outsideFences = (lines: readonly Line[]): Line[] => {
+  const fence = { open: false };
+  return lines.filter((line) => {
+    if (FENCE.test(line.text)) {
+      fence.open = !fence.open;
+      return false;
+    }
+    return !fence.open;
+  });
+};
+
+/** 比べるための形。全角を半角にそろえ（４ と 4）、空白・記号を消し、小文字にする。 */
+const comparable = (text: string): string =>
+  text
+    .replace(ATTRIBUTES, "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[\s\p{P}\p{S}]/gu, "");
+
+/** 頭の番号（1.2、2-1、第3章）と飾りを外した、比べるための形。 */
+const withoutNumber = (text: string): string => comparable(headingWords(text));
+
+/** text の終わりから、isTail に当たる字を外したもの。 */
+const trimTail = (text: string, isTail: (char: string) => boolean): string => {
+  const chars = [...text];
+  return chars.slice(0, chars.findLastIndex((char) => !isTail(char)) + 1).join("");
+};
+
+/** 見出しの行の題（頭と終わりの # を外す）。見出しでなければ undefined。 */
+const headingTitle = (line: string): string | undefined => {
+  if (!HEADING.test(line)) return undefined;
+  const withoutMarks = line.trim().replace(/^#+/u, "").trim();
+  return trimTail(withoutMarks, (char) => char === "#").trim();
+};
+
+/** 終わりのページ番号（「背景 ........ 3」の 3 と点線）。点線の無い数（Step 3）は題のうち。 */
+const withoutPageNumber = (text: string): string => {
+  const before = trimTail(text, (char) => DIGIT.test(char)).trimEnd();
+  if (before === text.trimEnd()) return text;
+  const title = trimTail(before, (char) => LEADER_DOTS.has(char));
+  return before.length - title.length >= MIN_LEADER ? title.trim() : text;
+};
+
+/** 項目の言葉と、項目の行の中でそれが始まる所。リンクなら字の部分（番号の後ろのリンク「1. [概要](#…)」も）。 */
+const entryOf = (item: string): { readonly text: string; readonly start: number } => {
+  const bracket = item.indexOf("[");
+  const link = bracket === -1 ? undefined : LINK_TEXT.exec(item.slice(bracket))?.groups?.["text"];
+  if (link !== undefined) return { text: withoutPageNumber(link), start: bracket + 1 };
+  return { text: withoutPageNumber(item.trim()), start: item.length - item.trimStart().length };
+};
+
+const matchesHeading = (entry: string, headings: readonly Heading[]): boolean =>
+  headings.some(
+    (heading) => comparable(heading.title) === comparable(entry) || (withoutNumber(entry) !== "" && withoutNumber(heading.title) === withoutNumber(entry)),
+  );
+
+/** 目次の見出しの下（次の見出しまで）の箇条書きの項目。 */
+const entriesUnder = (lines: readonly Line[], tocAt: number): Line[] => {
+  const after = lines.filter((line) => line.offset > tocAt);
+  const end = after.findIndex((line) => HEADING.test(line.text));
+  return (end === -1 ? after : after.slice(0, end)).flatMap((line) => {
+    const marker = LIST_ITEM.exec(line.text)?.[0];
+    if (marker === undefined) return [];
+    const entry = entryOf(line.text.slice(marker.length));
+    return [{ text: entry.text, offset: line.offset + marker.length + entry.start }];
+  });
+};
+
+/** 文書の目次の項目のうち、どの見出しとも合わないもの。 */
+export const strayTocEntries = (source: string, tocWords: readonly string[]): StrayTocEntry[] => {
+  const lines = outsideFences(linesOf(source));
+  const headings = lines.flatMap((line) => {
+    const title = headingTitle(line.text);
+    return title === undefined ? [] : [{ title, offset: line.offset }];
+  });
+  const tocNames = new Set(tocWords.map(comparable));
+  return headings
+    .filter((heading) => tocNames.has(comparable(heading.title)))
+    .flatMap((toc) => {
+      const entries = entriesUnder(lines, toc.offset).filter((entry) => entry.text !== "");
+      const others = headings.filter((heading) => heading !== toc);
+      const stray = entries.filter((entry) => !matchesHeading(entry.text, others));
+      return stray.length > entries.length * MAX_STRAY_SHARE ? [] : stray.map((entry) => ({ offset: entry.offset, entry: entry.text }));
+    });
+};
+
+export const tocHeading: Detector = (doc): Finding[] =>
+  strayTocEntries(
+    doc.source,
+    (doc.lexicons["toc-heading"] ?? []).map((entry) => entry.pattern),
+  ).map((stray) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, stray.offset, stray.offset + stray.entry.length),
+    values: { entry: stray.entry, offset: stray.offset },
+  }));

package/src/list-marks.ts

@@ -0,0 +1,106 @@
+// The bullets a document writes its lists with (`-`, `*`, `+`, and `・` typed at a line's start), where each list sits, and
+// the `・` lines Markdown folds into the item above. Pure; reads the source's Markdown tree.
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import type { Span } from "./plugin.ts";
+
+/** One bulleted list as the reader meets it: where its first item starts, how deep it sits among lists, and its bullet. */
+export type ListMark = {
+  readonly start: number;
+  readonly depth: number;
+  readonly mark: string;
+  /** The list written right before it in the same parent, when there is one: Markdown splits a list where the bullet changes. */
+  readonly previous: string | undefined;
+};
+
+/** Bullets Markdown reads as a list. */
+const MARKDOWN_BULLETS = new Set(["-", "*", "+"]);
+
+/** A bullet a Japanese writer types at a line's start. Markdown does not read it as a list, so the lines run together. */
+const TYPED_BULLET = "・";
+
+/** Blocks whose lists are someone else's or are not prose: quotations, code and HTML. */
+const SKIPPED = new Set(["blockquote", "code", "html"]);
+
+const bulletOf = (source: string, list: MarkdownNode): { readonly start: number; readonly mark: string } | undefined => {
+  const first = list.children?.[0];
+  const span = first === undefined ? undefined : spanOf(first);
+  const mark = span === undefined ? undefined : source.charAt(span.start);
+  return span === undefined || mark === undefined || !MARKDOWN_BULLETS.has(mark) ? undefined : { start: span.start, mark };
+};
+
+/** Where each line of a span starts, with the line's text. */
+const linesIn = (source: string, span: Span): { readonly start: number; readonly text: string }[] => {
+  const lines = source.slice(span.start, span.end).split("\n");
+  const read: { start: number; text: string }[] = [];
+  lines.forEach((text) => {
+    const previous = read.at(-1);
+    read.push({ start: previous === undefined ? span.start : previous.start + previous.text.length + 1, text });
+  });
+  return read;
+};
+
+/** The start of each line after the first that begins with a typed bullet. */
+const typedLineStarts = (source: string, paragraph: Span): number[] =>
+  linesIn(source, paragraph).flatMap((line, at) => {
+    const indent = line.text.length - line.text.trimStart().length;
+    return at > 0 && line.text.trimStart().startsWith(TYPED_BULLET) ? [line.start + indent] : [];
+  });
+
+/** Lines of a paragraph that start with a typed bullet; two or more in a row are a list the writer typed. */
+const typedListStart = (source: string, paragraph: Span): number | undefined => {
+  const lines = linesIn(source, paragraph).filter((line) => line.text.trim() !== "");
+  const typed = lines.filter((line) => line.text.trimStart().startsWith(TYPED_BULLET));
+  const first = typed[0];
+  return typed.length >= 2 && first !== undefined ? first.start + first.text.length - first.text.trimStart().length : undefined;
+};
+
+type Frame = { readonly node: MarkdownNode; readonly depth: number; readonly inItem: boolean };
+
+export type ListReading = {
+  readonly lists: readonly ListMark[];
+  /** `・` lines inside a Markdown list item's paragraph: Markdown joins them to the item above. */
+  readonly foldedTyped: readonly number[];
+};
+
+const listsOf = (source: string, node: MarkdownNode, depth: number): ListMark[] => {
+  const children = node.children ?? [];
+  return children.flatMap((child, at) => {
+    if (child.type !== "list") return [];
+    const bullet = bulletOf(source, child);
+    const before = children[at - 1];
+    const previous = before?.type === "list" ? bulletOf(source, before)?.mark : undefined;
+    return bullet === undefined ? [] : [{ ...bullet, depth, previous }];
+  });
+};
+
+const typedOf = (source: string, node: MarkdownNode, depth: number, inItem: boolean): { lists: ListMark[]; folded: number[] } => {
+  const span = spanOf(node);
+  if (node.type !== "paragraph" || span === undefined) return { lists: [], folded: [] };
+  if (inItem) return { lists: [], folded: typedLineStarts(source, span) };
+  const start = typedListStart(source, span);
+  return { lists: start === undefined ? [] : [{ start, depth, mark: TYPED_BULLET, previous: undefined }], folded: [] };
+};
+
+/**
+ * Every bulleted list outside quotations and code, with its depth among lists (a list in a list item is one deeper), in source
+ * order. A paragraph with two or more lines that start with `・` counts as a list at the paragraph's depth; the same lines in a
+ * list item's paragraph are folded into that item.
+ */
+export const readLists = (source: string, root: MarkdownNode): ListReading => {
+  const lists: ListMark[] = [];
+  const folded: number[] = [];
+  const pending: Frame[] = [{ node: root, depth: 0, inItem: false }];
+  for (let frame = pending.pop(); frame !== undefined; frame = pending.pop()) {
+    const { node, depth, inItem } = frame;
+    if (SKIPPED.has(node.type)) continue;
+    lists.push(...listsOf(source, node, depth));
+    const typed = typedOf(source, node, depth, inItem);
+    lists.push(...typed.lists);
+    folded.push(...typed.folded);
+    const childDepth = node.type === "list" ? depth + 1 : depth;
+    const childInItem = node.type === "listItem" || (inItem && node.type !== "list");
+    (node.children ?? []).forEach((child) => pending.push({ node: child, depth: childDepth, inItem: childInItem }));
+  }
+  const byStart = (left: number, right: number): number => left - right;
+  return { lists: lists.toSorted((left, right) => byStart(left.start, right.start)), foldedTyped: folded.toSorted(byStart) };
+};

package/src/rule-fields.ts

@@ -11,10 +11,14 @@ export type FieldProblem =
   | { readonly kind: "bad-group"; readonly written: string }
   | { readonly kind: "bad-use-for"; readonly written: string }
   | { readonly kind: "bad-summary"; readonly written: string }
+  | { readonly kind: "bad-text"; readonly written: string }
   | { readonly kind: "bad-example"; readonly written: string };
 
 export type FieldKind = FieldProblem["kind"];
 
+/** Every kind, for a caller that reports these among problems of its own. */
+export const FIELD_KINDS: ReadonlySet<string> = new Set<FieldKind>(["bad-depth", "bad-group", "bad-use-for", "bad-summary", "bad-example", "bad-text"]);
+
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
 const isText = (value: unknown): value is string => typeof value === "string" && value.trim() !== "";
@@ -41,6 +45,25 @@ const useForProblems = (useFor: unknown, genres: readonly string[]): FieldProble
 const summaryProblems = (summary: unknown): FieldProblem[] =>
   summary === undefined || isTextByLanguage(summary) ? [] : [{ kind: "bad-summary", written: printed(summary) }];
 
+/** A language as a key of a text by language: ja, en, pt-br. */
+const LANGUAGE_KEY = /^[a-z]{2,3}(?:-[a-z0-9]+)*$/iu;
+
+/** The texts a reader sees. Each may be one string or one per language. */
+const TEXT_FIELDS = ["name", "why", "how_to_fix", "message", "summary"] as const;
+
+/**
+ * A text by language whose key is not a language, or whose value is not a text. In YAML, { en: Write a date, or a
+ * number of days } is two entries, the second keyed " or a number of days": without this, the text is cut silently.
+ */
+const textProblems = (raw: Readonly<Record<string, unknown>>): FieldProblem[] =>
+  TEXT_FIELDS.flatMap((field) => {
+    const value = raw[field];
+    if (!isRecord(value)) return [];
+    return Object.entries(value)
+      .filter(([key, text]) => !LANGUAGE_KEY.test(key) || typeof text !== "string")
+      .map(([key]) => ({ kind: "bad-text" as const, written: `${field}: ${JSON.stringify(key)}` }));
+  });
+
 /** One example: before and after, each a text in every language or by language. */
 const isExamplePair = (value: unknown): boolean => isRecord(value) && isTextByLanguage(value["before"]) && isTextByLanguage(value["after"]);
 
@@ -68,6 +91,7 @@ export const fieldProblems = (raw: Readonly<Record<string, unknown>>, genres: re
   ...useForProblems(raw["use_for"], genres),
   ...exampleProblems(raw["example"]),
   ...depthProblems(raw["rewrite"]),
+  ...textProblems(raw),
 ];
 
 const TEXT: Texts<Readonly<Record<FieldKind, (written: string) => string>>> = {
@@ -77,6 +101,8 @@ const TEXT: Texts<Readonly<Record<FieldKind, (written: string) => string>>> = {
     "bad-use-for": (written) =>
       `use_for: ${written} はジャンルではありません。ジャンルかその頭（business、business/report）を並べます。一覧は npx chaffjs genres。`,
     "bad-summary": (written) => `summary: ${written} は読めません。一つの文字列か、言語ごとの文字列（{ ja: …, en: … }）で書きます。`,
+    "bad-text": (written) =>
+      `${written} は言語ではありません。{ } の中のカンマは項目の区切りになるので、カンマのある文は引用符で囲みます（en: "Write a date, or a number of days."）。`,
     "bad-example": (written) =>
       `example: ${written} の before と after が揃っていません。{ before, after } か、言語ごとに { ja: { before, after }, en: { before, after } } と書きます。`,
   },
@@ -86,6 +112,8 @@ const TEXT: Texts<Readonly<Record<FieldKind, (written: string) => string>>> = {
     "bad-use-for": (written) =>
       `use_for: ${written} is not a genre. List genres or their first part (business, business/report); npx chaffjs genres lists them.`,
     "bad-summary": (written) => `summary: cannot read ${written}. Write one string, or one per language ({ ja: …, en: … }).`,
+    "bad-text": (written) =>
+      `${written} is not a language. Inside { }, a comma separates entries, so quote a text that has one (en: "Write a date, or a number of days.").`,
     "bad-example": (written) =>
       `example: ${written} lacks a before or an after. Write { before, after }, or one per language: { ja: { before, after }, en: { before, after } }.`,
   },