chaffjs 0.18.0 → 0.19.0

package/src/fix-plan/plan.ts

@@ -0,0 +1,181 @@
+import type { Finding, LengthUnit, Lexicon, RuleDefinition } from "../plugin.ts";
+import type { RewritePair } from "../rule-guide.ts";
+import type { Skipped } from "../run.ts";
+import type { Outline, Shape } from "../outline/shape.ts";
+import { localized, messageOf } from "../render/text.ts";
+import { splitWords } from "../detectors/word-list.ts";
+import { COMPOSITE_RULE, recommendMode, type ModeChoice } from "./mode.ts";
+
+/** One flagged spot, where it is and what chaff said about it. */
+export type PlanSpot = { readonly line: number; readonly column: number; readonly quote: string; readonly message: string };
+
+/** A phrase's own hint from the lexicon ("時間を溶かす" → "時間がかかった（何に、どれだけ）"). */
+export type PhraseHint = { readonly phrase: string; readonly rewrite: string };
+
+/** Everything a rewriter needs for one rule: its direction and the spots it flagged. */
+export type RulePlan = {
+  readonly rule: string;
+  readonly name: string;
+  /** The rule's rewrite direction, or its how_to_fix when it has no rewrite block. */
+  readonly direction: string;
+  readonly keep: readonly string[];
+  readonly avoid: readonly string[];
+  /** The first of the rule's pairs, to copy the shape from. */
+  readonly pair: RewritePair | undefined;
+  readonly hints: readonly PhraseHint[];
+  readonly spots: readonly PlanSpot[];
+};
+
+/** A rule that measures the whole document, with what it said. */
+type DocumentSignal = { readonly rule: string; readonly message: string };
+
+export type FixPlan = {
+  readonly path: string;
+  /** Where the plan suggests saving the rewrite, so the check commands can be pasted as they are. */
+  readonly rewrittenPath: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly experimental: boolean;
+  readonly mode: ModeChoice;
+  readonly signals: readonly DocumentSignal[];
+  readonly outline: { readonly unit: LengthUnit; readonly shape: Shape };
+  readonly rules: readonly RulePlan[];
+  /** The rewrite and signal rules that did not run, and why: silence from them is not "checked and fine". */
+  readonly notRun: readonly Skipped[];
+  readonly checks: readonly string[];
+};
+
+export type PlanInput = {
+  readonly path: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly experimental: boolean;
+  /** --genre as given on the command line, repeated in the check commands. */
+  readonly genreFlag: string | undefined;
+  readonly findings: readonly Finding[];
+  readonly rules: readonly RuleDefinition[];
+  readonly skipped: readonly Skipped[];
+  readonly outline: Outline;
+  /** The ai-tell lexicon of the document's language, whose entries may carry their own hint. */
+  readonly phrases: Lexicon;
+};
+
+const BOLD_DENSITY_RULE = "bold-density";
+const AI_TELL_RULE = "ai-tell";
+
+/** ai-generated-composite's inputs and bold-density: the rules the guide reads as document-level signals. */
+const signalRulesOf = (rules: readonly RuleDefinition[]): ReadonlySet<string> =>
+  new Set([...(rules.find((rule) => rule.id === COMPOSITE_RULE)?.from ?? []), BOLD_DENSITY_RULE]);
+
+/** article.md → article.rewritten.md, beside the original. */
+export const rewrittenPathOf = (path: string): string => {
+  const dot = path.lastIndexOf(".");
+  const slash = path.lastIndexOf("/");
+  return dot > slash + 1 ? `${path.slice(0, dot)}.rewritten${path.slice(dot)}` : `${path}.rewritten`;
+};
+
+const SHELL_SAFE = /^[\w./-]+$/u;
+
+/** A single quote inside single quotes: close, an escaped quote, reopen. */
+const QUOTE_IN_QUOTES = "'\\''";
+
+/** A path as a shell reads it: quoted unless every character is plain. */
+export const shellPath = (path: string): string => (SHELL_SAFE.test(path) ? path : `'${path.replaceAll("'", QUOTE_IN_QUOTES)}'`);
+
+/** The ai-tell phrases the finding names that carry a hint of their own. */
+export const phraseHintsOf = (finding: Finding, phrases: Lexicon, language: string): PhraseHint[] => {
+  const named = new Set(splitWords(String(finding.values["word"] ?? ""), language));
+  return phrases.flatMap((entry) =>
+    entry.rewrite !== undefined && named.has(entry.pattern.toLowerCase()) ? [{ phrase: entry.pattern, rewrite: entry.rewrite }] : [],
+  );
+};
+
+const spotOf = (finding: Finding, rule: RuleDefinition, language: string): PlanSpot => ({
+  line: finding.line,
+  column: finding.column,
+  quote: finding.quote,
+  message: messageOf(rule, finding, language),
+});
+
+const rulePlanOf = (rule: RuleDefinition, findings: readonly Finding[], input: PlanInput): RulePlan => {
+  const rewrite = rule.guide?.rewrite[input.language];
+  const hints = rule.id === AI_TELL_RULE ? findings.flatMap((finding) => phraseHintsOf(finding, input.phrases, input.language)) : [];
+  return {
+    rule: rule.id,
+    name: localized(rule.name, input.language),
+    direction: rewrite?.direction ?? localized(rule.how_to_fix, input.language),
+    keep: rewrite?.keep ?? [],
+    avoid: rewrite?.avoid ?? [],
+    pair: rewrite?.pairs[0],
+    hints,
+    spots: findings.map((finding) => spotOf(finding, rule, input.language)),
+  };
+};
+
+/** The rules in the order their first finding appears; the composite has no spot of its own and is a signal only. */
+const rulePlansOf = (input: PlanInput): RulePlan[] => {
+  const order = [...new Set(input.findings.map((finding) => finding.rule))].filter((id) => id !== COMPOSITE_RULE);
+  return order.flatMap((id) => {
+    const rule = input.rules.find((entry) => entry.id === id);
+    return rule === undefined
+      ? []
+      : [
+          rulePlanOf(
+            rule,
+            input.findings.filter((finding) => finding.rule === id),
+            input,
+          ),
+        ];
+  });
+};
+
+/** The composite first, then each signal rule once, with what its first finding said. */
+const signalsOf = (input: PlanInput, signalRules: ReadonlySet<string>): DocumentSignal[] =>
+  [COMPOSITE_RULE, ...signalRules].flatMap((id) => {
+    const finding = input.findings.find((entry) => entry.rule === id);
+    const rule = input.rules.find((entry) => entry.id === id);
+    return finding === undefined || rule === undefined ? [] : [{ rule: id, message: messageOf(rule, finding, input.language) }];
+  });
+
+const hasRewrite = (rule: RuleDefinition): boolean => Object.keys(rule.guide?.rewrite ?? {}).length > 0;
+
+/** A rule written for other languages is not one that failed to run on this document. */
+const checksLanguage = (rule: RuleDefinition, language: string): boolean => rule.languages === undefined || rule.languages.includes(language);
+
+const notRunOf = (input: PlanInput, signalRules: ReadonlySet<string>): Skipped[] => {
+  const forThisLanguage = input.rules.filter((rule) => checksLanguage(rule, input.language));
+  const watched = new Set(forThisLanguage.filter((rule) => hasRewrite(rule) || rule.id === COMPOSITE_RULE || signalRules.has(rule.id)).map((rule) => rule.id));
+  return input.skipped.filter((skipped) => watched.has(skipped.rule));
+};
+
+/** The commands to run on the rewrite. A full rewrite cuts repeats and rebuilds headings, which compare is told. */
+const checksOf = (input: PlanInput, choice: ModeChoice): string[] => {
+  const original = shellPath(input.path);
+  const rewritten = shellPath(rewrittenPathOf(input.path));
+  const lintFlags = [...(input.experimental ? ["--experimental"] : []), ...(input.genreFlag === undefined ? [] : ["--genre", input.genreFlag])];
+  const compareFlags = choice.mode === "full" ? ["--distinct", "--allow-dropped heading", "--allow-added heading"] : [];
+  return [
+    ["npx chaffjs", rewritten, ...lintFlags].join(" "),
+    ["npx chaffjs compare", original, rewritten, ...compareFlags].join(" "),
+    ["npx chaffjs outline", original, rewritten].join(" "),
+  ];
+};
+
+/** The plan for one document: deterministic, from chaff's findings and the rule files alone. */
+export const buildFixPlan = (input: PlanInput): FixPlan => {
+  const signalRules = signalRulesOf(input.rules);
+  const mode = recommendMode({ genre: input.genre, firedRules: new Set(input.findings.map((finding) => finding.rule)), signalRules });
+  return {
+    path: input.path,
+    rewrittenPath: rewrittenPathOf(input.path),
+    language: input.language,
+    genre: input.genre,
+    experimental: input.experimental,
+    mode,
+    signals: signalsOf(input, signalRules),
+    outline: { unit: input.outline.unit, shape: input.outline.shape },
+    rules: rulePlansOf(input),
+    notRun: notRunOf(input, signalRules),
+    checks: checksOf(input, mode),
+  };
+};

package/src/fix-plan/render.ts

@@ -0,0 +1,128 @@
+import type { RewritePair } from "../rule-guide.ts";
+import { shapeMeasures } from "../outline/render.ts";
+import { OUTLINE_TEXT } from "../outline/text.ts";
+import { uiLanguageOf } from "../ui.ts";
+import type { FixPlan, PhraseHint, PlanSpot, RulePlan } from "./plan.ts";
+import { FIX_PLAN_TEXT, type FixPlanText } from "./text.ts";
+
+/** A phrase quoted the way the document's language quotes: 「…」 in Japanese, "…" otherwise. */
+const quoted = (text: string, language: string): string => (language === "ja" ? `「${text}」` : `"${text}"`);
+
+const bullets = (items: readonly string[]): string[] => items.map((item) => `- ${item}`);
+
+/** Each line of a passage as a Markdown quotation, so a list inside it stays a list and does not join the plan's own. */
+const blockquote = (passage: string): string[] =>
+  passage
+    .trimEnd()
+    .split("\n")
+    .map((line) => (line === "" ? ">" : `> ${line}`));
+
+const labelled = (label: string, lines: readonly string[]): string[] => (lines.length === 0 ? [] : ["", `**${label}**`, "", ...lines]);
+
+const pairLines = (pair: RewritePair | undefined, text: FixPlanText): string[] =>
+  pair === undefined ? [] : [`${text.before}:`, "", ...blockquote(pair.before), "", `${text.after}:`, "", ...blockquote(pair.after)];
+
+const hintLine = (hint: PhraseHint, language: string): string => `- ${quoted(hint.phrase, language)} → ${hint.rewrite}`;
+
+const spotLines = (spot: PlanSpot, text: FixPlanText, language: string): string[] => [
+  `- ${text.at(spot.line)}: ${quoted(spot.quote, language)}`,
+  `  ${spot.message}`,
+];
+
+const rulePlanLines = (rule: RulePlan, text: FixPlanText, language: string): string[] => [
+  "",
+  `### \`${rule.rule}\` ${rule.name}`,
+  "",
+  `**${text.direction}**: ${rule.direction}`,
+  ...labelled(text.keep, bullets(rule.keep)),
+  ...labelled(text.avoid, bullets(rule.avoid)),
+  ...labelled(text.example, pairLines(rule.pair, text)),
+  ...labelled(
+    text.phrases,
+    rule.hints.map((hint) => hintLine(hint, language)),
+  ),
+  ...labelled(
+    text.spots,
+    rule.spots.flatMap((spot) => spotLines(spot, text, language)),
+  ),
+];
+
+const modeLines = (plan: FixPlan, text: FixPlanText): string[] => [
+  "",
+  `## ${text.modeHeading}: ${text.modeName[plan.mode.mode]}`,
+  "",
+  text.modeReason[plan.mode.reason],
+  "",
+  ...bullets(text.modeWays),
+];
+
+const signalLines = (plan: FixPlan, text: FixPlanText): string[] => {
+  const outline = text.outlineLine(shapeMeasures(plan.outline.shape, plan.outline.unit, OUTLINE_TEXT[uiLanguageOf(plan.language)]));
+  const said = plan.signals.length === 0 ? [text.noSignals, ""] : [];
+  return ["", `## ${text.signalsHeading}`, "", ...said, ...bullets([...plan.signals.map((signal) => `\`${signal.rule}\`: ${signal.message}`), outline])];
+};
+
+const notRunLines = (plan: FixPlan, text: FixPlanText): string[] => {
+  const note = plan.experimental ? [] : [text.notExperimental];
+  const listed = plan.notRun;
+  if (note.length === 0 && listed.length === 0) return [];
+  return [
+    "",
+    `## ${text.notRunHeading}`,
+    "",
+    ...note,
+    ...(note.length > 0 && listed.length > 0 ? [""] : []),
+    ...bullets(listed.map((skipped) => `\`${skipped.rule}\`: ${skipped.why}`)),
+  ];
+};
+
+const checkLines = (plan: FixPlan, text: FixPlanText): string[] => [
+  "",
+  `## ${text.checksHeading}`,
+  "",
+  text.saveAs(plan.rewrittenPath),
+  "",
+  "```bash",
+  ...plan.checks,
+  "```",
+  "",
+  text.checksNote,
+];
+
+const textOf = (plan: FixPlan): FixPlanText => FIX_PLAN_TEXT[uiLanguageOf(plan.language)];
+
+/** The plan as Markdown, in the document's language: what an agent reads before rewriting. */
+export const renderFixPlanMarkdown = (plan: FixPlan): string => {
+  const text = textOf(plan);
+  return [
+    `# ${text.title(plan.path)}`,
+    "",
+    text.about(plan.language, plan.genre),
+    "",
+    text.intro,
+    "",
+    `## ${text.constraintsHeading}`,
+    "",
+    ...text.constraints.map((constraint, index) => `${String(index + 1)}. ${constraint}`),
+    ...modeLines(plan, text),
+    ...signalLines(plan, text),
+    ...(plan.rules.length === 0 ? [] : ["", `## ${text.rulesHeading}`]),
+    ...plan.rules.flatMap((rule) => rulePlanLines(rule, text, plan.language)),
+    ...notRunLines(plan, text),
+    ...checkLines(plan, text),
+  ].join("\n");
+};
+
+/** The same plan as JSON, with the constraints and the mode's reason in the document's language. */
+export const renderFixPlanJson = (plan: FixPlan): string => {
+  const text = textOf(plan);
+  return JSON.stringify(
+    {
+      ...plan,
+      constraints: text.constraints,
+      mode: { ...plan.mode, name: text.modeName[plan.mode.mode], why: text.modeReason[plan.mode.reason] },
+    },
+    null,
+    2,
+  );
+};

package/src/fix-plan/text.ts

@@ -0,0 +1,133 @@
+import type { Texts } from "../ui.ts";
+import type { FixMode, ModeReason } from "./mode.ts";
+
+export type FixPlanText = {
+  readonly usage: string;
+  readonly notFound: (path: string) => string;
+  readonly title: (path: string) => string;
+  readonly about: (language: string, genre: string) => string;
+  readonly intro: string;
+  readonly constraintsHeading: string;
+  readonly constraints: readonly string[];
+  readonly modeHeading: string;
+  readonly modeName: Readonly<Record<FixMode, string>>;
+  readonly modeReason: Readonly<Record<ModeReason, string>>;
+  readonly modeWays: readonly string[];
+  readonly signalsHeading: string;
+  readonly noSignals: string;
+  readonly outlineLine: (measures: string) => string;
+  readonly rulesHeading: string;
+  readonly direction: string;
+  readonly keep: string;
+  readonly avoid: string;
+  readonly example: string;
+  readonly before: string;
+  readonly after: string;
+  readonly phrases: string;
+  readonly spots: string;
+  readonly at: (line: number) => string;
+  readonly notRunHeading: string;
+  readonly notExperimental: string;
+  readonly checksHeading: string;
+  readonly saveAs: (path: string) => string;
+  readonly checksNote: string;
+};
+
+export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
+  ja: {
+    usage: "使い方: chaff fix-plan <file> [--experimental] [--genre <ジャンル>] [--json]",
+    notFound: (path) => `${path} がありません。`,
+    title: (path) => `直す計画: ${path}`,
+    about: (language, genre) => `言語 ${language}、ジャンル ${genre}`,
+    intro:
+      "chaff が機械で見つけた箇所と、それぞれの直す方向です。chaff は書き直しません。書き直すのは、この計画を読む人か AI です。直したら、最後の確かめのコマンドを実行してください。",
+    constraintsHeading: "守ること",
+    constraints: [
+      "事実、数、日付、条件、名前を変えない。",
+      "元の文書に無い事実、人、数、原因、例を足さない。",
+      "直すのに文書に無い具体（誰が、いつ、どれだけ）が要るときは、作らずに［ ］で空けて書き手に聞く。",
+      "書き直しは 2 回まで。指摘を消すためだけに書き直しを繰り返さない。",
+    ],
+    modeHeading: "勧める直し方",
+    modeName: { none: "直すところなし", light: "軽く直す（Light）", bold: "大胆に直す（Bold）", full: "全面書き直し（Full）" },
+    modeReason: {
+      "nothing-found": "chaff は何も見つけませんでした。",
+      composite: "ai-generated-composite が出ています。文の言い回しを直しても、生成文の骨組みが残ります。",
+      genre: "ブログやエッセイは、構成から書き直すほうが書き手の望みに合います。",
+      signals: "文書全体を測るルールが 2 つ以上出ています。見出しの構成は残し、節ごとに文を書き直します。",
+      spots: "指摘は箇所ごとです。指摘された所だけを直します。",
+    },
+    modeWays: [
+      "軽く直す: 指摘された箇所だけ。",
+      "大胆に直す: 見出しの構成は残し、節ごとに文を書き直す。",
+      "全面書き直し: 事実と主張を控えてから、構成から書き直す。頼まれた内容が「全面的に」「一から」なら、これを選ぶ。",
+    ],
+    signalsHeading: "文書全体の目印",
+    noSignals: "文書全体を測るルールは、何も言っていません。",
+    outlineLine: (measures) => `構成: ${measures}`,
+    rulesHeading: "ルールごとの直し方",
+    direction: "直す方向",
+    keep: "変えないもの",
+    avoid: "やりがちな間違い",
+    example: "例",
+    before: "前",
+    after: "後",
+    phrases: "言い回しごとの手がかり",
+    spots: "見つけた箇所",
+    at: (line) => `${String(line)} 行目`,
+    notRunHeading: "動かなかったルール",
+    notExperimental: "試験中のルールは動かしていません。AIっぽさのルールの多くは試験中です。--experimental を付けると見ます。",
+    checksHeading: "直したあとの確かめ",
+    saveAs: (path) => `書き直したものを ${path} に保存して、次を実行します。`,
+    checksNote:
+      "1 つめは書き直した文書の指摘、2 つめは事実が落ちていないか・足されていないか、3 つめは構成の変化です。数は chaff の出力から取り、形容詞で言わないでください。",
+  },
+  en: {
+    usage: "usage: chaff fix-plan <file> [--experimental] [--genre <genre>] [--json]",
+    notFound: (path) => `${path} does not exist.`,
+    title: (path) => `Fix plan: ${path}`,
+    about: (language, genre) => `language ${language}, genre ${genre}`,
+    intro:
+      "What chaff found by machine, and how to rewrite each kind of spot. chaff does not rewrite; whoever reads this plan does, a person or an AI. When done, run the checks at the end.",
+    constraintsHeading: "Constraints",
+    constraints: [
+      "Keep every fact, number, date, condition and name.",
+      "Add no fact, person, number, cause or example the original does not have.",
+      "Where a fix needs a specific the text does not give (who, when, how much), do not invent it: leave [ ] and ask the writer.",
+      "At most two passes. Do not rewrite again just to silence a finding.",
+    ],
+    modeHeading: "Recommended way",
+    modeName: { none: "Nothing to fix", light: "Light", bold: "Bold", full: "Full rewrite" },
+    modeReason: {
+      "nothing-found": "chaff found nothing.",
+      composite: "ai-generated-composite fires. Fixing the wording would leave the skeleton of generated text.",
+      genre: "For a blog post or an essay, what the writer wants changed is usually the structure.",
+      signals: "Two or more rules that measure the whole document fire. Keep the outline and rewrite the prose section by section.",
+      spots: "The findings are single spots. Rewrite only those.",
+    },
+    modeWays: [
+      "Light: only the flagged spots.",
+      "Bold: keep the outline, rewrite the prose of each section.",
+      'Full: take an inventory of the facts and claims, then rewrite from the structure up. If the request says "from scratch", choose this.',
+    ],
+    signalsHeading: "Document-level signals",
+    noSignals: "None of the rules that measure the whole document said anything.",
+    outlineLine: (measures) => `Outline: ${measures}`,
+    rulesHeading: "How to rewrite, rule by rule",
+    direction: "Direction",
+    keep: "Keep",
+    avoid: "Avoid",
+    example: "Example",
+    before: "before",
+    after: "after",
+    phrases: "Hints for the phrases found",
+    spots: "Spots",
+    at: (line) => `line ${String(line)}`,
+    notRunHeading: "Rules that did not run",
+    notExperimental: "The experimental rules did not run, and most rules for generated text are experimental. Add --experimental to run them.",
+    checksHeading: "Check after rewriting",
+    saveAs: (path) => `Save the rewrite as ${path} and run:`,
+    checksNote:
+      "The first lists the rewrite's findings, the second checks that no fact was dropped or added, the third shows how the outline moved. Take the numbers from chaff's output, not adjectives.",
+  },
+};

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/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

@@ -29,8 +29,11 @@ export type KanaWord = {
   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;
+/**
+ * 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";
 
@@ -81,14 +84,21 @@ const sameWordGroups = (words: readonly KanaWord[]): KanaWord[][] => {
  */
 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 ー. 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 (カー).
+ * 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): 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 }));
+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

package/src/markup.ts

@@ -1,5 +1,5 @@
 import { spanOf, type MarkdownNode } from "./markdown-node.ts";
-import { headingText } from "./heading-text.ts";
+import { atxHeadingText, headingText } from "./heading-text.ts";
 import { eachPreOrder } from "./tree-walk.ts";
 import { alertReader } from "./template-syntax.ts";
 import { cutSpans } from "./span-cut.ts";
@@ -84,7 +84,9 @@ const readHeading = (node: MarkdownNode, span: Span, source: string, walk: Walk)
   // 名前は書いたままの行から読む。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)));
+  // ATX（行頭が #）なら閉じの # も外す。`## Install ## {#install}` の言葉は「Install」。
+  const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
+  const text = withoutMdxComment(read(plainText(node, source)));
   walk.headings.push({ depth: numberField(node, "depth") ?? 1, text, start: span.start, end: span.end });
 };