chaffjs 0.17.0 → 0.19.0

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/language-sample.ts

@@ -0,0 +1,48 @@
+import { readMarkdown, spansOfType } from "./markdown-read.ts";
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import { maskSpans } from "./mask.ts";
+import type { Span } from "./plugin.ts";
+
+/**
+ * The text the document's language is guessed from: what the writer wrote in it. Fenced code, inline code, HTML tags
+ * and comments, HTML code blocks (`<script>`, `<pre>` and the like), YAML front matter, a site generator's syntax (MDX imports, component lines) and URLs are blanked out.
+ * A technical article in Japanese can hold more Latin letters in its code than kana and kanji in its prose. The text
+ * between HTML tags is kept: a `<details>` block holds prose. Indented code is kept too: in plain text an indented
+ * paragraph is prose, and Markdown would read it as code.
+ */
+
+const FENCE = /^ {0,3}(?:```|~~~)/u;
+const URL_PATTERN = /\b[a-z][a-z\d+.-]*:\/\/[^\s<>"'`)\]]+/giu;
+const NOT_WRITTEN_IN_IT: readonly string[] = ["inlineCode", "yaml"];
+/** HTML whose content is not prose: a comment, or a block that holds code (CommonMark's raw HTML blocks, and `<code>`). */
+const NOT_PROSE_HTML = /^\s*(?:<!--|<(?:script|style|pre|textarea|code)\b)/iu;
+
+const isFenced = (source: string) => (node: MarkdownNode) => {
+  const span = spanOf(node);
+  return span !== undefined && FENCE.test(source.slice(span.start, span.end));
+};
+
+const urlSpans = (source: string): Span[] => [...source.matchAll(URL_PATTERN)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** The tags in an HTML node (`<…>`), found with indexOf so that a stray `<` costs one scan, not a backtrack. */
+const tagSpans = (source: string, node: Span): Span[] => {
+  const spans: Span[] = [];
+  let open = source.indexOf("<", node.start);
+  while (open !== -1 && open < node.end) {
+    const close = source.indexOf(">", open);
+    if (close === -1 || close >= node.end) break;
+    spans.push({ start: open, end: close + 1 });
+    open = source.indexOf("<", close + 1);
+  }
+  return spans;
+};
+
+/** A comment or a code block is blanked whole; any other HTML keeps the text between its tags. */
+const htmlSpans = (source: string, nodes: readonly Span[]): Span[] =>
+  nodes.flatMap((node) => (NOT_PROSE_HTML.test(source.slice(node.start, node.end)) ? [node] : tagSpans(source, node)));
+
+export const languageSample = (source: string): string => {
+  const { root, syntax } = readMarkdown(source);
+  const code = [...spansOfType(root, "code", isFenced(source)), ...NOT_WRITTEN_IN_IT.flatMap((type) => spansOfType(root, type))];
+  return maskSpans(source, [...code, ...htmlSpans(source, spansOfType(root, "html")), ...syntax, ...urlSpans(source)]);
+};

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/link-line.ts

@@ -0,0 +1,13 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 行が一つのリンクだけか。前後の空白を除いた行が、どれかのリンクの範囲とちょうど重なる。
+ * 記事の一覧のようにリンクを 1 行ずつ並べた段落では、句点が無くても行ごとに一つの項目と読まれる。
+ * line と links は source の中の位置。
+ */
+export const isLinkLine = (source: string, line: Span, links: readonly Span[]): boolean => {
+  const text = source.slice(line.start, line.end);
+  const start = line.start + text.length - text.trimStart().length;
+  const end = line.end - (text.length - text.trimEnd().length);
+  return links.some((link) => link.start === start && link.end === end);
+};

package/src/long-vowel.ts

@@ -0,0 +1,109 @@
+// 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 before its final ー: カー is one, カバー two, コンピューター five. JIS Z 8301:2011 Table G.3 counts so:
+ * カバー is its example of a word of two sounds or fewer, which keeps the ー.
+ */
+export const stemMorae = (surface: string): number => moraCount(stemOf(surface));
+
+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"));
+
+/** Whether drop reaches the word: its final ー follows one of the kana the guideline drops it after (ア段: -er, -or, -ar). Any, when none are given. */
+const droppable = (word: KanaWord, dropAfter: ReadonlySet<string> | undefined): boolean =>
+  dropAfter === undefined || dropAfter.has(Array.from(stemOf(word.surface)).at(-1) ?? "");
+
+/**
+ * The words that go against the chosen way. drop: a word of minMorae or more written with its final ー after a kana of dropAfter.
+ * 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, dropAfter?: ReadonlySet<string>): Odd[] => {
+  const counted = words.filter((word) => stemMorae(word.surface) >= minMorae);
+  if (ending === "drop")
+    return counted
+      .filter((word) => word.long && droppable(word, dropAfter))
+      .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)] };
+};