chaffjs 0.17.0 → 0.18.0

package/src/eval.ts

@@ -1,7 +1,9 @@
 import { DETECTORS } from "./detectors/index.ts";
 import { charLength } from "./measure.ts";
-import type { ProseDocument, RuleDefinition } from "./plugin.ts";
+import type { DetectorOptions, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
 import { missingList } from "./declared-lists.ts";
+import { bodySectionOf } from "./body-section.ts";
 
 /**
  * 閾値の較正。
@@ -44,12 +46,12 @@ const candidates = (rule: RuleDefinition, current: number): number[] => {
   return [...new Set([...fromLevels, ...scaled, current])].toSorted((left, right) => left - right);
 };
 
-const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
+const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number, settings: DetectorOptions["settings"]): Point => {
   const detector = DETECTORS[rule.how_to_find];
   if (detector === undefined) return { limit, findings: 0, documents: 0, per10k: 0 };
   const perDoc = docs.map((doc) => {
     const lexicon = rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list];
-    return detector(doc, { limit, lexicon, where: rule.where }).length;
+    return detector(doc, { limit, lexicon, where: rule.where, settings }).length;
   });
   const findings = perDoc.reduce((sum, count) => sum + count, 0);
   const chars = docs.reduce((sum, doc) => sum + doc.sentences.reduce((inner, sentence) => inner + charLength(sentence), 0), 0);
@@ -71,6 +73,10 @@ const meets = (need: string, docs: readonly ProseDocument[]): boolean => {
   if (need === "lemma") return capabilities?.lemma === true;
   // 木は adapter が structure を持つときだけ作れる。無いまま測ると、どの閾値でも 0 件になる。
   if (need === "structure") return docs.length > 0 && docs.every((doc) => doc.structure !== undefined);
+  // 見出しの無い文書では lint が動かない。見出しのある文書が 1 つも無ければ、どの閾値でも 0 件になる。
+  if (need === "headings") return docs.some((doc) => bodySectionOf(doc.sections) !== undefined);
+  // 記法を読む rule は Markdown の文書でしか動かない。
+  if (need === "markdown") return docs.some((doc) => doc.markup?.markdown === true);
   return false;
 };
 
@@ -80,6 +86,8 @@ const meets = (need: string, docs: readonly ProseDocument[]): boolean => {
  */
 const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre: string, language: string): boolean => {
   if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
+  // A rule with nothing to count has no limit to sweep: its levels set severity.
+  if (rule.level_sets === "severity") return false;
   if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
   if (rule.from.length > 0) return false;
   if (docs.some((doc) => missingList(rule, doc.lexicons) !== undefined)) return false;
@@ -96,12 +104,14 @@ export const evaluate = (
   genre: string,
   language: string,
   limits: Readonly<Record<string, number>> = {},
+  optionLayers: readonly OptionLayer[] = [],
 ): RuleReport[] =>
   rules
     .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
       const current = limits[rule.id] ?? rule.levels.normal ?? 1;
-      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit));
+      const settings = rule.options === undefined ? undefined : optionValues(settleOptions(rule.id, rule.options, optionLayers));
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit, settings));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,

package/src/figure-references.ts

@@ -0,0 +1,112 @@
+import { escapeRegExp } from "./orthography.ts";
+import type { Span } from "./plugin.ts";
+
+/**
+ * 本文で番号を指した図・表・付録（図3、Table 2、Appendix B）と、それを行の頭に書いた所（キャプション、見出し）。
+ * 行の頭に一度も書いていない番号を指していれば、参照先が無い。その種類（図、表）を行の頭に一つも書いていない文書は見ない。
+ * 図が別の紙にある文書かもしれない。言語の知識（図や表の語、略した書き方、別の文書を指す語）は語彙表から受け取る。
+ */
+type LabelWord = {
+  readonly word: string;
+  /** 同じものを指す書き方をまとめる名前。「Fig.」は Figure。 */
+  readonly kind: string;
+};
+
+export type LabelWords = {
+  readonly labels: readonly LabelWord[];
+  /** 番号のすぐ後ろにあると、別の文書の図になる語（of、in）。 */
+  readonly elsewhere: readonly string[];
+  /** 番号のすぐ後ろにあると、図の数になる語（図3枚）。 */
+  readonly counters: readonly string[];
+};
+
+export type DanglingFigure = { readonly offset: number; readonly label: string };
+
+type Mention = { readonly start: number; readonly end: number; readonly written: string; readonly key: string; readonly kind: string };
+
+/** 語の前の字が漢字・カタカナ・英数字なら、長い語の一部（地図3、一覧表2、法別表第二、SubFigure）。 */
+const INSIDE_WORD = "(?<![\\p{Script=Han}\\p{Script=Katakana}\\p{N}A-Za-z])";
+/** 番号。数字（3、3.2、第3）、「第」の後の漢数字（別表第一）、大文字一つかローマ数字（Appendix B、Annex II）。 */
+const NUMBER = "[ \\t\\u00a0]?(?:第?(\\p{Nd}+(?:[.\\-－]\\p{Nd}+)*)|第([一二三四五六七八九十百]+)|([IVX]{2,5}|[A-ZＡ-Ｚ])(?![A-Za-z]))";
+
+const forms = (word: string): string[] => [...new Set([word, word.toUpperCase()])];
+
+const mentionPattern = (labels: readonly LabelWord[]): RegExp => {
+  const words = labels
+    .flatMap((label) => forms(label.word))
+    .toSorted((a, b) => b.length - a.length)
+    .map(escapeRegExp);
+  return new RegExp(`${INSIDE_WORD}(${words.join("|")})${NUMBER}`, "gu");
+};
+
+const kindOf = (written: string, labels: readonly LabelWord[]): string => labels.find((label) => forms(label.word).includes(written))?.kind ?? written;
+
+/** 同じ図は同じ鍵。全角の数字と字は半角に揃える。 */
+const mentionsIn = (text: string, labels: readonly LabelWord[]): Mention[] =>
+  [...text.matchAll(mentionPattern(labels))].map((match) => {
+    const kind = kindOf(match[1] ?? "", labels);
+    const number = (match[2] ?? match[3] ?? match[4] ?? "").normalize("NFKC");
+    return { start: match.index, end: match.index + match[0].length, written: match[0].trim(), key: `${kind}\u0000${number}`, kind };
+  });
+
+type Scan = { readonly depth: number; readonly kept: string; readonly previous: string };
+
+/** 開きの括弧。「(」はリンクの行き先（[...](...)）のときだけ、つまり「]」のすぐ後ろだけ。 */
+const opens = (char: string, previous: string): boolean => char === "[" || char === "<" || (char === "(" && previous === "]");
+const CLOSERS = "])>";
+
+const step = (state: Scan, char: string): Scan => {
+  if (opens(char, state.previous)) return { depth: state.depth + 1, kept: state.kept, previous: char };
+  if (state.depth > 0 && CLOSERS.includes(char)) return { depth: state.depth - 1, kept: state.kept, previous: char };
+  return { depth: state.depth, kept: state.depth === 0 ? state.kept + char : state.kept, previous: char };
+};
+
+/** 括弧の外の字。リンクと画像の書き方（[...](...)）と HTML の札（<b>）の中身は、行の頭の飾りとして読み飛ばす。 */
+const outsideMarkup = (text: string): string => [...text].reduce(step, { depth: 0, kept: "", previous: "" }).kept;
+const LETTER = /\p{L}/u;
+
+const HEADING = /^[ \t]{0,3}#/u;
+
+/**
+ * 番号の後ろが題の区切りか。行の終わり、区切りの記号（: . — | 括弧）、または空白のあとの題の書き出し。
+ * 空白のあとがひらがなか英語の小文字なら、本文の文（図3の例では、Figure 3 shows）で、キャプションではない。
+ */
+const CAPTION_AFTER = /^(?:[ \t]*$|[:：.．—–\-|()（）【】\]*_]|[ \t\u3000]+[^\p{Script=Hiragana}\p{Ll}])/u;
+
+/**
+ * 行の頭に書いた番号。前にあるのが飾り（#、**、![、|、【、箇条書きの印）だけで、見出しの中か、後ろが題の区切りならキャプション。
+ * 行の頭から始まる本文の文（図３の例では、…）は、図の置き場所ではない。
+ */
+const isLabelled = (source: string, mention: Mention): boolean => {
+  const lineStart = source.lastIndexOf("\n", mention.start - 1) + 1;
+  const lineEnd = source.indexOf("\n", mention.end);
+  const before = source.slice(lineStart, mention.start);
+  if (LETTER.test(outsideMarkup(before))) return false;
+  return HEADING.test(before) || CAPTION_AFTER.test(source.slice(mention.end, lineEnd === -1 ? source.length : lineEnd));
+};
+
+const LATIN_WORD = /^[A-Za-z]/u;
+
+/** 番号のすぐ後ろの語。別の文書の図（Figure 5 of the report）か、図の数（図3枚）なら参照として見ない。 */
+const pointsHere = (text: string, mention: Mention, words: LabelWords): boolean => {
+  const after = text.slice(mention.end);
+  const trimmed = after.trimStart();
+  const elsewhere = words.elsewhere.some((word) => after !== trimmed && trimmed.startsWith(word) && !LATIN_WORD.test(trimmed.slice(word.length)));
+  return !elsewhere && !words.counters.some((word) => after.startsWith(word));
+};
+
+/**
+ * 参照先の無い番号。source は行の頭を読み、prose（コードを覆った本文）は参照を読む。位置は同じ。
+ * 番号は、キャプションが 1 と書けば 1a や 1(b) の参照も 1 に当たる（番号の後ろの字は読まない）。
+ * リンクの字（[Figure 2](figures.md)）は、そのリンクが行き先を持つので参照として見ない。
+ */
+export const danglingFigures = (source: string, prose: string, words: LabelWords, links: readonly Span[] = []): DanglingFigure[] => {
+  if (words.labels.length === 0) return [];
+  const labelled = mentionsIn(source, words.labels).filter((mention) => isLabelled(source, mention));
+  const labelledKeys = new Set(labelled.map((mention) => mention.key));
+  const labelledKinds = new Set(labelled.map((mention) => mention.kind));
+  return mentionsIn(prose, words.labels)
+    .filter((mention) => labelledKinds.has(mention.kind) && !labelledKeys.has(mention.key))
+    .filter((mention) => pointsHere(prose, mention, words) && !links.some((link) => link.start <= mention.start && mention.end <= link.end))
+    .map((mention) => ({ offset: mention.start, label: mention.written }));
+};

package/src/files.ts

@@ -1,5 +1,10 @@
 import { globSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
+import { plainSource } from "./plain-source.ts";
+
+/** 検査する文書を読む。言語・ジャンル・stet も文書モデルと同じ本文（BOM と CRLF / CR をそろえたもの）で読むため、ここでそろえる。 */
+export const readDocumentFile = async (path: string): Promise<string> => plainSource(await readFile(path, "utf8"));
 
 const MARKDOWN = [".md", ".markdown", ".mdx"];
 

package/src/heading-label.ts

@@ -0,0 +1,55 @@
+import type { Lexicon, NumberingContext, StructurePatterns, Token } from "./plugin.ts";
+import { universalNumber } from "./structure/universal.ts";
+
+const ON_HEADING: NumberingContext = { open: [], isHeading: true };
+
+/** 木を組むときと同じ読み方（numbering-gap が比べる番号）で読んだ、番号の後ろの題。「第2章 概要」「Chapter 2: Setup」「1. はじめに」。 */
+const numberedTitle = (heading: string, patterns: StructurePatterns): string | undefined => {
+  const numbered = patterns.numbered(heading, ON_HEADING) ?? universalNumber(patterns, heading, ON_HEADING, false);
+  return numbered === undefined || numbered.heading === "" ? undefined : numbered.heading;
+};
+
+const SPECIAL = /[.*+?^${}()|[\]\\]/gu;
+
+/**
+ * 番号の前に書いて名前を付ける語（語彙表 numbered-label の before: 例・問・Step）と番号と区切りで始まる見出しの、札の部分。
+ * 区切りはコロンか空白。札の後ろに題が無ければ当てない。木はこの札を番号として読まない。
+ */
+export const labelPatternOf = (labelWords: readonly string[]): RegExp | undefined => {
+  if (labelWords.length === 0) return undefined;
+  const words = labelWords.map((word) => word.replace(SPECIAL, String.raw`\$&`)).join("|");
+  return new RegExp(String.raw`^(?:${words})[ \t\u3000]?[0-9０-９]+(?:[.．][0-9０-９]+)*(?:[ \t\u3000]*[:：][ \t\u3000]*|[ \t\u3000]+)(?=\S)`, "u");
+};
+
+/**
+ * 見出しの頭の番号の札を除いた題。札は本文で繰り返されないので、見出しと文の重なりを測るときは数えない。
+ * 番号は木と同じ読み方で読み、木が読まない札（「例 3：」「Step 3:」）は語彙表の語で読む。札が無ければ見出しのまま。
+ */
+export const unlabeledHeading = (heading: string, patterns: StructurePatterns | undefined, labelPattern: RegExp | undefined): string => {
+  const titled = patterns === undefined ? undefined : numberedTitle(heading, patterns);
+  if (titled !== undefined) return titled;
+  const label = labelPattern?.exec(heading)?.[0];
+  return label === undefined ? heading : heading.slice(label.length);
+};
+
+/**
+ * 見出しごとに、札を除いた題を読まれたときに一度だけ読む関数。読むのは heading-echo だけなので、ほかの rule には番号を読む代金を払わせない。
+ * 札の語は語彙表 numbered-label の before。
+ */
+export const unlabeledReader = (patterns: StructurePatterns | undefined, lexicons: Readonly<Record<string, Lexicon>>): ((heading: string) => () => string) => {
+  const labelWords = (lexicons["numbered-label"] ?? []).filter((entry) => entry.position === "before").map((entry) => entry.pattern);
+  const labelPattern = labelPatternOf(labelWords);
+  return (heading) => {
+    const memo: { value?: string } = {};
+    return () => (memo.value ??= unlabeledHeading(heading, patterns, labelPattern));
+  };
+};
+
+/**
+ * 見出しの語のうち、札より後ろ（題）のもの。tokens の位置は見出しの中の位置。札の語（例・Step）を見出しにある語と数えると、
+ * 文が札の語を使っただけ（例として…）で「見出しに無い語を足していない」ことになる。
+ */
+export const titleTokens = (heading: string, title: string, tokens: readonly Token[]): readonly Token[] => {
+  const titleStart = heading.lastIndexOf(title);
+  return tokens.filter((token) => token.span.start >= titleStart);
+};

package/src/in-page-nav.ts

@@ -1,3 +1,5 @@
+import { eachPreOrder } from "./tree-walk.ts";
+
 /** mdast の節のうち、ページ内の案内かどうかの判定に要る部分だけ。 */
 export type NavNode = {
   readonly type: string;
@@ -17,28 +19,44 @@ const WRAPPERS = new Set(["strong", "emphasis", "delete"]);
 
 const pointsInPage = (url: string | undefined): boolean => (url ?? "").startsWith("#");
 
-const collectAnchors = (node: NavNode, found: Set<string>): void => {
-  if (node.type === "definition" && node.identifier !== undefined && pointsInPage(node.url)) found.add(node.identifier);
-  (node.children ?? []).forEach((child) => collectAnchors(child, found));
-};
-
 export const inPageAnchors = (root: NavNode): InPageAnchors => {
   const found = new Set<string>();
-  collectAnchors(root, found);
+  eachPreOrder(root, (node) => {
+    if (node.type === "definition" && node.identifier !== undefined && pointsInPage(node.url)) found.add(node.identifier);
+  });
   return found;
 };
 
 const isInPageLink = (node: NavNode, anchors: InPageAnchors): boolean =>
   (node.type === "link" && pointsInPage(node.url)) || (node.type === "linkReference" && anchors.has(node.identifier ?? ""));
 
+/** What must also be a part for this node to be one: nothing for a link or symbols, the children of emphasis. undefined when it is prose. */
+const partsWithin = (node: NavNode, anchors: InPageAnchors): readonly NavNode[] | undefined => {
+  if (isInPageLink(node, anchors) || node.type === "break") return [];
+  if (node.type === "text") return WORD.test(node.value ?? "") ? undefined : [];
+  return WRAPPERS.has(node.type) ? (node.children ?? []) : undefined;
+};
+
 const isNavigationPart = (node: NavNode, anchors: InPageAnchors): boolean => {
-  if (isInPageLink(node, anchors) || node.type === "break") return true;
-  if (node.type === "text") return !WORD.test(node.value ?? "");
-  return WRAPPERS.has(node.type) && (node.children ?? []).every((child) => isNavigationPart(child, anchors));
+  const pending: NavNode[] = [node];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    const within = next === undefined ? [] : partsWithin(next, anchors);
+    if (within === undefined) return false;
+    within.forEach((child) => pending.push(child));
+  }
+  return true;
 };
 
-const containsInPageLink = (node: NavNode, anchors: InPageAnchors): boolean =>
-  isInPageLink(node, anchors) || (node.children ?? []).some((child) => containsInPageLink(child, anchors));
+const containsInPageLink = (node: NavNode, anchors: InPageAnchors): boolean => {
+  const pending: NavNode[] = [node];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next !== undefined && isInPageLink(next, anchors)) return true;
+    (next?.children ?? []).forEach((child) => pending.push(child));
+  }
+  return false;
+};
 
 /**
  * 同じページの中へのリンク（`](#…)`）と記号だけでできた段落。「▲ 目次に戻る」や目次の項目で、本文ではなくページの案内。
@@ -53,15 +71,26 @@ export const isInPageNavigation = (paragraph: NavNode, anchors: InPageAnchors =
   );
 };
 
-const isNavigationBlock = (node: NavNode, anchors: InPageAnchors): boolean => isInPageNavigation(node, anchors) || isNavigationList(node, anchors);
-
-const isNavigationItem = (item: NavNode, anchors: InPageAnchors): boolean => {
-  const children = item.children ?? [];
-  return item.type === "listItem" && children.length > 0 && children.every((child) => isNavigationBlock(child, anchors));
+/** The blocks inside a list's items, or undefined unless it is a list whose every item holds a block. */
+const itemBlocks = (list: NavNode): readonly NavNode[] | undefined => {
+  const items = list.children ?? [];
+  if (list.type !== "list" || items.length === 0) return undefined;
+  const blocks = items.map((item) => (item.type === "listItem" ? (item.children ?? []) : []));
+  return blocks.some((children) => children.length === 0) ? undefined : blocks.flat();
 };
 
-/** 項目がどれもページの案内（入れ子も含む）の箇条書き。目次の項目の数は節の数で決まり、書いた人が選んだ並べ方ではない。 */
+/**
+ * 項目がどれもページの案内（入れ子も含む）の箇条書き。目次の項目の数は節の数で決まり、書いた人が選んだ並べ方ではない。
+ * 項目の中の段落はページの案内の段落で、段落でない塊は、それ自身がページの案内の箇条書き。
+ */
 export const isNavigationList = (list: NavNode, anchors: InPageAnchors = new Set()): boolean => {
-  const items = list.children ?? [];
-  return list.type === "list" && items.length > 0 && items.every((item) => isNavigationItem(item, anchors));
+  const pending: NavNode[] = [list];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    const blocks = next === undefined ? [] : itemBlocks(next);
+    if (blocks === undefined) return false;
+    if (!blocks.every((block) => block.type !== "paragraph" || isInPageNavigation(block, anchors))) return false;
+    blocks.filter((block) => block.type !== "paragraph").forEach((block) => pending.push(block));
+  }
+  return true;
 };

package/src/joined-view.ts

@@ -61,6 +61,7 @@ const sentenceInSource =
       span,
       text: text.slice(span.start, span.end),
       ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map(tokenInSource(view)) }),
+      ...(sentence.embeddedLanguage === undefined ? {} : { embeddedLanguage: sentence.embeddedLanguage }),
     };
   };
 

package/src/levels.ts

@@ -1,4 +1,4 @@
-import type { Level, LevelTable, RuleDefinition } from "./plugin.ts";
+import type { Level, LevelTable, RuleDefinition, Severity } from "./plugin.ts";
 
 const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
 
@@ -37,3 +37,16 @@ export const resolve = (rule: RuleDefinition, level: Level, genre?: string): Res
 
 /** その rule が実際に区別できる段だけを返す。CLI の案内に使う。 */
 export const definedLevels = (rule: RuleDefinition): Level[] => LEVELS.filter((level) => level === "off" || rule.levels[level] !== undefined);
+
+/** Lightest first: a level table holds info as 1, warning as 2 and error as 3. */
+const SEVERITY_BY_RANK: readonly Severity[] = ["info", "warning", "error"];
+
+/** A severity written in a level table, as the number the table holds. */
+export const rankOfSeverity = (value: unknown): number | undefined => {
+  const index = SEVERITY_BY_RANK.findIndex((entry) => entry === value);
+  return index === -1 ? undefined : index + 1;
+};
+
+/** The severity a rule with nothing to count gives its findings at a level. A counting rule keeps its own. */
+export const severityAt = (rule: RuleDefinition, level: Exclude<Level, "off">, genre?: string): Severity =>
+  rule.level_sets === "severity" ? (SEVERITY_BY_RANK[resolve(rule, level, genre).limit - 1] ?? rule.severity) : rule.severity;

package/src/line-paragraphs.ts

@@ -10,6 +10,7 @@ import type { Span } from "./plugin.ts";
  *   （議事録は発言者の行と発言の行が交互に来るので、半分ちょうどは割る）。
  * - 1 行 1 文の書き方（行を意味の切れ目で改める。英語の Markdown に多い）は、段落のつもりではない。
  *   文の頭で始まり文の終わりで終わる行が 2 文以上を持つことが、段落を 1 行に書いた印。それがたまにしか無ければ割らない。
+ *   この印は文書全体で数える（documentIsLineShaped）。
  */
 
 /** 2 文以上を持つ行がこれより少なければ、1 行 1 文の書き方にたまに混じる 2 文の行と見分けられない。 */
@@ -69,18 +70,60 @@ const sentencesIn = (group: Span, cores: readonly Span[]): number => firstStarti
 const wholeMultiSentenceLines = (lines: readonly Line[], closing: readonly boolean[], cores: readonly Span[]): number =>
   lines.filter((line, index) => (index === 0 || closing[index - 1] === true) && closing[index] === true && sentencesIn(line.span, cores) >= 2).length;
 
-/** 行ごとの段落として読む形か。 */
-const isLineShaped = (lines: readonly Line[], closing: readonly boolean[], groups: readonly Span[], cores: readonly Span[]): boolean => {
-  const closed = closing.filter(Boolean).length;
-  const multi = wholeMultiSentenceLines(lines, closing, cores);
-  return closed * 2 >= closing.length && multi >= MIN_MULTI_SENTENCE && multi >= groups.length * MULTI_SENTENCE_SHARE;
+/** 1 つの段落の形: 割るならどこで割るか（groups）と、行ごとの段落と読む手がかり。 */
+type Shape = {
+  readonly paragraph: Span;
+  readonly groups: readonly Span[];
+  readonly lines: number;
+  /** 文で終わる行が半分以上。届かなければ固定幅の折り返し。 */
+  readonly mostlyClosed: boolean;
+  /** 文の頭で始まり文の終わりで終わる、2 文以上の行の数。 */
+  readonly multi: number;
 };
 
-/** paragraph を、書いた人が段落のつもりで改めた行ごとに割る。そう読めなければ paragraph 1 つ。sentences は段落の中の文。 */
-export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] => {
+const shapeOf = (source: string, paragraph: Span, sentences: readonly Span[]): Shape => {
   const lines = linesOf(source, paragraph);
   const cores = sentences.map((sentence) => coreOf(source, sentence)).filter((core) => core.end > core.start);
   const closing = lines.map((line) => hasText(source, line) && endsSentence(line, cores));
-  const groups = groupAt(lines, closing);
-  return isLineShaped(lines, closing, groups, cores) ? groups : [paragraph];
+  return {
+    paragraph,
+    groups: groupAt(lines, closing),
+    lines: lines.length,
+    mostlyClosed: closing.filter(Boolean).length * 2 >= closing.length,
+    multi: wholeMultiSentenceLines(lines, closing, cores),
+  };
+};
+
+/** 2 文以上の行が、1 行 1 文の書き方にたまに混じる数より多い。 */
+const enoughMulti = (multi: number, groups: number): boolean => multi >= MIN_MULTI_SENTENCE && multi >= groups * MULTI_SENTENCE_SHARE;
+
+/**
+ * 文書が 1 行 1 段落で書かれているか。書き方は書き手のもので、段落 1 つずつでは決まらない（見出しごとの短い段落が並ぶ演説）。
+ * 手がかりは、2 行以上あって折り返しでない段落だけから集める。1 行だけの段落は空行で区切った普通の段落で、1 行 1 段落の印ではない。
+ */
+const documentIsLineShaped = (shapes: readonly Shape[]): boolean => {
+  const evidence = shapes.filter((shape) => shape.lines > 1 && shape.mostlyClosed);
+  const total = (count: (shape: Shape) => number): number => evidence.reduce((sum, shape) => sum + count(shape), 0);
+  return enoughMulti(
+    total((shape) => shape.multi),
+    total((shape) => shape.groups.length),
+  );
 };
+
+/** 割るか: 折り返しでなく、段落だけで、または文書全体で、行ごとの段落と読める。 */
+const splits = (shape: Shape, lineShapedDocument: boolean): boolean =>
+  shape.mostlyClosed && (lineShapedDocument || enoughMulti(shape.multi, shape.groups.length));
+
+/**
+ * 文書の段落（並び順）を、書いた人が段落のつもりで改めた行ごとに割った段落。そう読めない段落はそのまま。
+ * sentences は段落の中の文。
+ */
+export const documentLineParagraphs = (source: string, paragraphs: readonly { readonly span: Span; readonly sentences: readonly Span[] }[]): Span[] => {
+  const shapes = paragraphs.map((paragraph) => shapeOf(source, paragraph.span, paragraph.sentences));
+  const lineShaped = documentIsLineShaped(shapes);
+  return shapes.flatMap((shape) => (splits(shape, lineShaped) ? shape.groups : [shape.paragraph]));
+};
+
+/** paragraph を、書いた人が段落のつもりで改めた行ごとに割る。そう読めなければ paragraph 1 つ。sentences は段落の中の文。 */
+export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] =>
+  documentLineParagraphs(source, [{ span: paragraph, sentences }]);

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)] };
+};