chaffjs 0.17.0 → 0.19.0

package/src/run.ts

@@ -1,6 +1,6 @@
 import { DETECTORS } from "./detectors/index.ts";
-import { resolve } from "./levels.ts";
-import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { resolve, severityAt } from "./levels.ts";
+import type { AdapterNeeds, Detector, DetectorOptions, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
 import { joinWords } from "./detectors/word-list.ts";
@@ -11,8 +11,20 @@ import { maskSpans } from "./mask.ts";
 import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
 import { presetLevels } from "./genre-load.ts";
+import { bodySectionOf } from "./body-section.ts";
+import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
+import { byPosition } from "./finding-order.ts";
+import { PatternTimeout } from "./custom/bounded-match.ts";
+import { PluginRuleFailure } from "./extension/module-detector.ts";
+import { failureReason } from "./extension/failure-text.ts";
+import { tagCoverage } from "./tag-coverage.ts";
 
-export type Skipped = { readonly rule: string; readonly why: string };
+export type Skipped = {
+  readonly rule: string;
+  readonly why: string;
+  /** Off only because it is experimental: --experimental (or chaff.yaml's experimental) would run it. */
+  readonly offUntilExperimental?: true;
+};
 
 export type RunResult = {
   readonly findings: readonly Finding[];
@@ -37,9 +49,10 @@ const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolea
 };
 
 /** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, or it is experimental. */
-const offReason = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): string => {
-  if (settings[rule.id] !== undefined) return reasons.turnedOff;
-  return preset[rule.id] === undefined ? reasons.experimental : reasons.presetOff(genre);
+const offSkip = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): Skipped => {
+  if (settings[rule.id] !== undefined) return { rule: rule.id, why: reasons.turnedOff };
+  if (preset[rule.id] !== undefined) return { rule: rule.id, why: reasons.presetOff(genre) };
+  return { rule: rule.id, why: reasons.experimental, offUntilExperimental: true };
 };
 
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
@@ -68,7 +81,7 @@ const treeProblem = (doc: ProseDocument): string | undefined => {
 
 /** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はページの飾りだけを覆ったもの（.txt の字下げはコードではない）。 */
 const textTheTreeRead = (doc: ProseDocument): string =>
-  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source).opaque);
+  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source, doc.replyQuotes).opaque);
 
 const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
 
@@ -78,6 +91,15 @@ const unreadOf = (doc: ProseDocument): Unread | undefined => {
   return unreadByDocument.get(doc);
 };
 
+/** 見出しを読む rule の要求。表題より下の見出しが無い文書では、本題の前を測れない。0 件を「前置きが短い」に見せない。 */
+/** 記法を読む rule の要求（markdown）。.txt には見出しの記法も画像もリンクの記法も無いので、0 件を「問題なし」に見せない。 */
+const DOCUMENT_NEEDS: ReadonlySet<string> = new Set(["headings", "markdown"]);
+
+const documentNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
+  if (rule.requires.includes("markdown") && !isMarkdownPath(doc.path)) return reasonsFor(doc).notMarkdown;
+  return rule.requires.includes("headings") && bodySectionOf(doc.sections) === undefined ? reasonsFor(doc).noHeadings : undefined;
+};
+
 /** 知らない要求は満たされていないものとして扱う。黙って無視すると、要求なしで動いてしまう。 */
 const has = (capabilities: ProseDocument["capabilities"], need: string): boolean => {
   if (need === "pos") return capabilities.pos;
@@ -90,14 +112,18 @@ const has = (capabilities: ProseDocument["capabilities"], need: string): boolean
  *
  * `capabilities.pos: true` と言いながら token を返さないアダプタでも、rule は
  * `sentence.tokens ?? []` を見るので**例外にならず、指摘 0 件で終わる**。
- * 0 件は「問題なし」と見分けがつかない。
+ * 0 件は「問題なし」と見分けがつかない。一部の文にだけ token が無いとき（解析器が読めなかった段落）も、その段落の 0 件が同じく保証に見える。
  */
-const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 || doc.sentences.some((sentence) => sentence.tokens !== undefined);
+const tagReason = (doc: ProseDocument): string | undefined => {
+  const coverage = tagCoverage(doc.sentences);
+  if (coverage === "all") return undefined;
+  return coverage === "none" ? reasonsFor(doc).noTags : reasonsFor(doc).unreadTags;
+};
 
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return reasonsFor(doc).otherLanguage(doc.language);
-  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
+  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need) && !DOCUMENT_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
   if (missing !== undefined) return reasonsFor(doc).noCapability(missing);
   return undefined;
 };
@@ -107,7 +133,7 @@ const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined =>
  * 先に聞くと、止めている rule まで「アダプタが品詞を返さなかった」と、違う理由で出る。
  */
 const untagged = (rule: RuleDefinition, doc: ProseDocument): string | undefined =>
-  rule.requires.some((need) => need === "pos" || need === "lemma") && !hasTokens(doc) ? reasonsFor(doc).noTags : undefined;
+  rule.requires.some((need) => need === "pos" || need === "lemma") ? tagReason(doc) : undefined;
 
 const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefinition[] =>
   rules.filter((rule) => rule.use_for.some((target) => genre.startsWith(target)));
@@ -119,12 +145,34 @@ export const wantsTags = (rule: RuleDefinition): boolean => [...rule.requires, .
  * 解析器の初期化に払う代金を決める。動く rule が 1 本も要求しないなら読み込まない。
  * capabilities は「払えばできる」の宣言なので、ここでは見ない。
  */
-export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => ({
-  pos: forGenre(rules, genre)
+export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => {
+  const running = forGenre(rules, genre)
     .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental, presetLevels(genre)) !== "off")
-    .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
-    .some(wantsTags),
-});
+    .filter((rule) => rule.languages === undefined || rule.languages.includes(language));
+  return { pos: running.some(wantsTags), features: tokenFeaturesOf(running) };
+};
+
+/** The token features the rules read (RuleDefinition.token_features), each once. */
+export const tokenFeaturesOf = (rules: readonly RuleDefinition[]): string[] => [...new Set(rules.flatMap((rule) => rule.token_features ?? []))];
+
+/**
+ * A detector's findings, or why the rule did not run: a team's pattern stopped at its time limit (bounded-match.ts), or a
+ * plugin's detector that threw or returned something else than findings (module-detector.ts). Other errors are chaff's
+ * bugs and propagate.
+ */
+const runDetector = (
+  detector: Detector,
+  doc: ProseDocument,
+  options: DetectorOptions,
+): { readonly findings: readonly Finding[] } | { readonly notRun: string } => {
+  try {
+    return { findings: detector(doc, options) };
+  } catch (error) {
+    if (error instanceof PatternTimeout) return { notRun: reasonsFor(doc).patternTimeout(error.budget_ms) };
+    if (error instanceof PluginRuleFailure) return { notRun: failureReason(error.origin, error.failure, uiLanguageOf(doc.language)) };
+    throw error;
+  }
+};
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
   const offset = finding.values["offset"];
@@ -160,6 +208,31 @@ export type Limits = Readonly<Record<string, number>>;
 
 const limitFor = (rule: RuleDefinition, level: Level, genre: string, limits: Limits): number => limits[rule.id] ?? resolve(rule, level, genre).limit;
 
+/** 文書と違う言語で書いた文の上限。chaff.yaml の数値は文書の言語の単位で書いたものなので、ここには効かせない。 */
+const embeddedLimitsFor = (rule: RuleDefinition, level: Level, genre: string, embedded: readonly string[]): Record<string, number> =>
+  Object.fromEntries(
+    embedded.flatMap((language) => {
+      const tables = rule.other_languages?.[language];
+      return tables === undefined ? [] : [[language, resolve({ ...rule, ...tables }, level, genre).limit] as const];
+    }),
+  );
+
+const embeddedLanguagesOf = (doc: ProseDocument): string[] => [
+  ...new Set(doc.sentences.flatMap((sentence) => (sentence.embeddedLanguage === undefined ? [] : [sentence.embeddedLanguage.id]))),
+];
+
+/** What a run is set to: the levels chaff.yaml names, whether experimental rules run, the genre, and the numbers and options set. */
+export type RunContext = {
+  readonly settings: Settings;
+  readonly experimental: boolean;
+  readonly genre: string;
+  readonly limits?: Limits;
+  /** Where rule options come from, strongest first (chaff.yaml). An option no layer sets is at its default. */
+  readonly optionLayers?: readonly OptionLayer[];
+  /** The detectors loaded from the code chaff.yaml names, by rule id. They come before chaff's own table. */
+  readonly detectors?: Readonly<Record<string, Detector>>;
+};
+
 export const runRules = (
   doc: ProseDocument,
   rules: readonly RuleDefinition[],
@@ -167,10 +240,14 @@ export const runRules = (
   experimental: boolean,
   genre: string,
   limits: Limits = {},
-): RunResult => {
+): RunResult => runRulesWith(doc, rules, { settings, experimental, genre, limits });
+
+export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[], context: RunContext): RunResult => {
+  const { settings, experimental, genre, limits = {}, optionLayers = [], detectors = {} } = context;
   const preset = presetLevels(genre);
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
+  const embedded = embeddedLanguagesOf(doc);
   const experimentalOn = applicable.filter((rule) => rule.status === "experimental" && levelFor(rule, settings, experimental, preset) !== "off");
   const forced = experimentalOn.filter((rule) => settings[rule.id] !== undefined).map((rule) => rule.id);
   const presetOn = experimentalOn.filter((rule) => settings[rule.id] === undefined && preset[rule.id] !== undefined).map((rule) => rule.id);
@@ -183,17 +260,18 @@ export const runRules = (
       const blocked = unmet(rule, doc);
       if (blocked !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: blocked }] };
       const level = levelFor(rule, settings, experimental, preset);
-      if (level === "off")
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: offReason(rule, settings, preset, genre, reasonsFor(doc)) }] };
+      if (level === "off") return { findings: acc.findings, skipped: [...acc.skipped, offSkip(rule, settings, preset, genre, reasonsFor(doc))] };
       const noTags = untagged(rule, doc);
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
       const noTree = treeNeed(rule, doc);
       if (noTree !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTree }] };
+      const noDocumentNeed = documentNeed(rule, doc);
+      if (noDocumentNeed !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noDocumentNeed }] };
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
-      const detector = DETECTORS[rule.how_to_find];
+      const detector = detectors[rule.id] ?? DETECTORS[rule.how_to_find];
       if (detector === undefined)
         return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noDetector(rule.how_to_find) }] };
       // 語彙表を要求する rule で、その言語に語彙表が無ければ動かせない。黙って通さない。
@@ -205,8 +283,13 @@ export const runRules = (
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
         fullSentence: rule.full_sentence,
+        embeddedLimits: embeddedLimitsFor(rule, level, genre, embedded),
+        ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, optionLayers)) }),
+        ...(rule.custom === undefined ? {} : { custom: rule.custom }),
       };
-      const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
+      const ran = runDetector(detector, doc, options);
+      if ("notRun" in ran) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: ran.notRun }] };
+      const found = ran.findings.map((finding) => place(starts, { ...finding, rule: rule.id, severity: severityAt(rule, level, genre) }));
       return { findings: [...acc.findings, ...found], skipped: acc.skipped };
     },
     { findings: [], skipped: [] },
@@ -217,5 +300,5 @@ export const runRules = (
       compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental, preset), genre, limits), starts, doc.language),
     );
   const all = [...outcome.findings, ...composites];
-  return { ...outcome, findings: all.toSorted((left, right) => left.line - right.line), forcedExperimental: forced, presetExperimental: presetOn };
+  return { ...outcome, findings: all.toSorted(byPosition), forcedExperimental: forced, presetExperimental: presetOn };
 };

package/src/sentence-shape.ts

@@ -1,4 +1,5 @@
 import type { Sentence, Token } from "./plugin.ts";
+import { ownEnd } from "./trailing-aside.ts";
 
 /**
  * 「これは文か」の判定を 1 箇所に置く。
@@ -21,13 +22,11 @@ const SKIP = new Set(["PUNCT", "PART", "SYM"]);
  * 「これを最優先制約とする（§17）。」の述語は「とする」であって「17」ではない。
  * 仕様書は相互参照を括弧で添えるので、これを数えると文末が全部そこになる。
  */
-const TRAILING = /[(（][^(（]*[)）][\s。．！？!?]*$/u;
-
 const beforeTrailing = (sentence: Sentence): readonly Token[] => {
   const tokens = sentence.tokens ?? [];
-  const match = TRAILING.exec(sentence.text);
-  if (match?.index === undefined) return tokens;
-  const cut = sentence.span.start + match.index;
+  const end = ownEnd(sentence.text);
+  if (end === sentence.text.length) return tokens;
+  const cut = sentence.span.start + end;
   const kept = tokens.filter((token) => token.span.end <= cut);
   // 括弧を外したら何も残らない文は、括弧そのものが中身。そのまま見る。
   return kept.length === 0 ? tokens : kept;

package/src/setting-problems.ts

@@ -1,5 +1,10 @@
 import type { Config } from "./config/load.ts";
 import type { CliText } from "./cli-text.ts";
+import type { UiLanguage } from "./ui.ts";
+import { styleProblems } from "./config/style.ts";
+import { loadStyles } from "./style-load.ts";
+import { customRuleProblems } from "./custom/problems.ts";
+import { extensionProblems } from "./extension/problem-text.ts";
 import { GENRES } from "./genre.ts";
 import { unknownGenres, writtenGenres } from "./genre-check.ts";
 import { loadProfiles } from "./profile/load.ts";
@@ -18,7 +23,10 @@ const profileProblems = (command: string, config: Config, text: CliText): string
 };
 
 /** Settings that name something chaff does not have. Each would silently check less than was asked, so the run stops on them. */
-export const settingProblems = (command: string, genreFlag: string | undefined, config: Config, text: CliText): string[] => [
+export const settingProblems = (command: string, genreFlag: string | undefined, config: Config, text: CliText, ui: UiLanguage = "en"): string[] => [
   ...genreProblems(command, genreFlag, config, text),
   ...profileProblems(command, config, text),
+  ...styleProblems(config, [...loadStyles(), ...(config.extensions?.styles ?? [])], ui),
+  ...customRuleProblems(config, ui),
+  ...extensionProblems(config, ui),
 ];

package/src/spacing-minority.ts

@@ -0,0 +1,27 @@
+import { minorityStyle } from "./orthography.ts";
+
+/**
+ * 少ないほうがこの割合を超えると、書き損じではなく、書き方が二通りある文書と読む。1 箇所ずつ「違う」と指すと、
+ * 半々に近い文書でどちらかの側に立つことになる。そのときは 1 件にまとめて、両方の数を言う。
+ */
+const MIXED_SHARE = 0.2;
+
+/** 割合が大きくても、これより少なければ 1 箇所ずつ言う。3 箇所のうち 1 箇所なら、その 1 箇所を見せるほうが早い。 */
+const MIN_MIXED = 5;
+
+/** each は少ないほうを 1 箇所ずつ、mixed は文書に書き方が二通りあることを 1 件で。first は少ないほうの最初の箇所。 */
+export type MinorityReport<T> =
+  | { readonly mode: "each"; readonly odd: readonly T[] }
+  | { readonly mode: "mixed"; readonly first: T; readonly odd: number; readonly spaced: number; readonly touching: number };
+
+/** 一つの種類の境目から、何をどう言うか。混ざっていない、または少ないほうが limit に届かなければ言わない。 */
+export const minorityReport = <T extends { readonly spaced: boolean }>(ofKind: readonly T[], limit: number): MinorityReport<T> | undefined => {
+  const minority = minorityStyle(ofKind);
+  if (minority === undefined) return undefined;
+  const odd = ofKind.filter((entry) => entry.spaced === minority);
+  const first = odd[0];
+  if (first === undefined || odd.length < limit) return undefined;
+  if (odd.length < MIN_MIXED || odd.length <= ofKind.length * MIXED_SHARE) return { mode: "each", odd };
+  const spaced = ofKind.filter((entry) => entry.spaced).length;
+  return { mode: "mixed", first, odd: odd.length, spaced, touching: ofKind.length - spaced };
+};

package/src/span-cut.ts

@@ -0,0 +1,28 @@
+import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
+import { firstEndingAfter } from "./soft-break.ts";
+
+const piecesOutside = (span: Span, sortedCuts: readonly Span[]): Span[] => {
+  const overlapping = sortedCuts
+    .slice(firstEndingAfter(sortedCuts, span.start), firstEndingAfter(sortedCuts, span.end) + 1)
+    .filter((cut) => cut.start < span.end);
+  const { pieces, cursor } = overlapping.reduce<{ pieces: Span[]; cursor: number }>(
+    (acc, cut) => ({
+      pieces: cut.start > acc.cursor ? [...acc.pieces, { start: acc.cursor, end: cut.start }] : acc.pieces,
+      cursor: Math.max(acc.cursor, cut.end),
+    }),
+    { pieces: [], cursor: span.start },
+  );
+  return cursor < span.end ? [...pieces, { start: cursor, end: span.end }] : pieces;
+};
+
+/** The parts of each span that no cut covers, in order. Cuts may overlap one another and come in any order. */
+export const cutSpans = (spans: readonly Span[], cuts: readonly Span[]): Span[] => {
+  if (cuts.length === 0) return [...spans];
+  const sortedCuts = mergeSpans(cuts, true);
+  return spans.flatMap((span) => piecesOutside(span, sortedCuts));
+};
+
+/** cutSpans, less the pieces of `source` that hold only white space. */
+export const cutTextSpans = (spans: readonly Span[], cuts: readonly Span[], source: string): Span[] =>
+  cuts.length === 0 ? [...spans] : cutSpans(spans, cuts).filter((piece) => source.slice(piece.start, piece.end).trim() !== "");

package/src/stet-block.ts

@@ -0,0 +1,60 @@
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import type { Span } from "./plugin.ts";
+
+/**
+ * Where a `<!-- stet: … -->` (scope next) stops: the end of the block right after the comment, as the Markdown parser
+ * reads it — a paragraph, a heading, a whole list, a table, a code block, a quote. Inside a list item, the item's next
+ * block. Plain text reads the same way: its paragraphs are the runs between blank lines.
+ */
+
+/** Containers whose children are blocks. Anywhere else, an HTML comment sits inside a paragraph or a heading. */
+const BLOCK_CONTAINERS: ReadonlySet<string> = new Set(["root", "listItem", "blockquote"]);
+
+type Holder = { readonly parent: MarkdownNode; readonly index: number };
+
+/** The child holding `offset`, or -1. Binary search: siblings are in source order, and a document can hold thousands of stets. */
+const childHolding = (children: readonly MarkdownNode[], offset: number): number => {
+  let low = 0;
+  let high = children.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const span = spanOf(children[middle] ?? { type: "" });
+    if (span === undefined) return -1;
+    if (offset < span.start) high = middle - 1;
+    else if (offset >= span.end) low = middle + 1;
+    else return middle;
+  }
+  return -1;
+};
+
+/** The deepest node holding `offset`, as its parent and its place among the parent's children. A loop: quotes nest without limit. */
+const holderOf = (root: MarkdownNode, offset: number): Holder | undefined => {
+  let found: Holder | undefined;
+  let parent: MarkdownNode | undefined = root;
+  while (parent !== undefined) {
+    const children: readonly MarkdownNode[] = parent.children ?? [];
+    const index = childHolding(children, offset);
+    if (index !== -1) found = { parent, index };
+    parent = children[index];
+  }
+  return found;
+};
+
+/** The node a stet covers: the next block when the comment stands alone, else the block the comment is part of. */
+const coveredNode = (source: string, holder: Holder, comment: Span): MarkdownNode | undefined => {
+  const siblings = holder.parent.children ?? [];
+  const node = siblings[holder.index];
+  if (node === undefined) return undefined;
+  if (!BLOCK_CONTAINERS.has(holder.parent.type)) return holder.parent;
+  const span = spanOf(node);
+  const alone = span !== undefined && source.slice(span.start, span.end).trim() === source.slice(comment.start, comment.end);
+  return alone ? siblings[holder.index + 1] : node;
+};
+
+/** The last line a `stet` (scope next) covers, for the comment at `comment` in a document parsed as `root`. */
+export const stetBlockEnd = (source: string, root: MarkdownNode, comment: Span, lineAt: (offset: number) => number): number => {
+  const holder = holderOf(root, comment.start);
+  const covered = holder === undefined ? undefined : coveredNode(source, holder, comment);
+  const end = covered === undefined ? undefined : spanOf(covered)?.end;
+  return lineAt(end ?? comment.end);
+};

package/src/stet.ts

@@ -1,9 +1,15 @@
 import type { Finding, Span } from "./plugin.ts";
+import { RULE_ID } from "./extension/plugin-name.ts";
+import { stetBlockEnd } from "./stet-block.ts";
+import { lineStarts, placeOf } from "./position.ts";
+import { parse } from "./markdown-read.ts";
 
 export type Suppression = {
   readonly rules: readonly string[];
   readonly reason: string | undefined;
   readonly line: number;
+  /** The last line a `stet` (scope next) covers: the end of the block right below the comment. Other scopes: the comment's last line. */
+  readonly blockEnd: number;
   readonly scope: "next" | "section" | "file";
 };
 
@@ -23,10 +29,6 @@ const SCOPE: Readonly<Record<string, Suppression["scope"]>> = { stet: "next", "s
 /** 理由は em dash のあと。書かなくてもよいが、書かないと chaff suppressions に並ぶ。 */
 const REASON_MARK = "\u2014";
 
-const RULE_ID = /^[a-z][a-z0-9-]*$/u;
-
-const lineOf = (source: string, offset: number): number => source.slice(0, offset).split("\n").length;
-
 const splitBody = (body: string): { rules: string[]; reason: string | undefined } => {
   const at = body.indexOf(REASON_MARK);
   const head = at === -1 ? body : body.slice(0, at);
@@ -43,37 +45,61 @@ const splitBody = (body: string): { rules: string[]; reason: string | undefined
   };
 };
 
-export const parseSuppressions = (source: string): Suppression[] =>
-  [...source.matchAll(PATTERN)].map((match) => ({
-    ...splitBody(match[2] ?? ""),
-    line: lineOf(source, match.index),
-    scope: SCOPE[match[1] ?? "stet"] ?? "next",
-  }));
+const scopeOf = (match: RegExpMatchArray): Suppression["scope"] => SCOPE[match[1] ?? "stet"] ?? "next";
+
+/** 1-based line of an offset, from a table built once: a document can hold thousands of stets. */
+const lineFinder = (source: string): ((offset: number) => number) => {
+  const starts = lineStarts(source);
+  return (offset) => placeOf(starts, offset).line;
+};
 
-/** stet が効く範囲。next は直後の塊、section は次の見出しまで、file は全体。 */
-const NEXT_LINES = 6;
+export const parseSuppressions = (source: string): Suppression[] => {
+  const matches = [...source.matchAll(PATTERN)];
+  const lineAt = lineFinder(source);
+  // Only a plain stet needs the tree, to find the block it stops at; a stet-file alone does not pay for a parse.
+  const root = matches.some((match) => scopeOf(match) === "next") ? parse(source) : undefined;
+  return matches.map((match) => {
+    const comment = { start: match.index, end: match.index + match[0].length };
+    const scope = scopeOf(match);
+    return {
+      ...splitBody(match[2] ?? ""),
+      line: lineAt(match.index),
+      blockEnd: root !== undefined && scope === "next" ? stetBlockEnd(source, root, comment, lineAt) : lineAt(comment.end),
+      scope,
+    };
+  });
+};
 
+/** stet が効く範囲。next は直後の塊（段落・見出し・箇条書き・表）の終わりまで、section は次の見出しまで、file は全体。 */
 const covers = (suppression: Suppression, finding: Finding, sectionEnds: readonly number[], lastLine: number): boolean => {
   if (!suppression.rules.includes(finding.rule)) return false;
   if (suppression.scope === "file") return true;
   // 抑制は「この先の箇所」に対して書く。遡って効くと、意図せず黙る範囲が広がる。
   if (finding.line < suppression.line) return false;
-  if (suppression.scope === "next") return finding.line - suppression.line <= NEXT_LINES;
+  if (suppression.scope === "next") return finding.line <= suppression.blockEnd;
   return finding.line <= (sectionEnds.find((line) => line > suppression.line) ?? lastLine);
 };
 
 export type Suppressed = { readonly finding: Finding; readonly suppression: Suppression };
 
-export type Applied = { readonly kept: readonly Finding[]; readonly suppressed: readonly Suppressed[]; readonly unusedReasonless: readonly Suppression[] };
+export type Applied = {
+  readonly kept: readonly Finding[];
+  readonly suppressed: readonly Suppressed[];
+  readonly unusedReasonless: readonly Suppression[];
+  /** Every rule a stet in the document names, whether or not it silenced anything. */
+  readonly named: readonly string[];
+};
 
 export const applySuppressions = (source: string, findings: readonly Finding[], sections: readonly Span[]): Applied => {
   const suppressions = parseSuppressions(source);
-  const sectionEnds = sections.map((span) => lineOf(source, span.end));
+  const lineAt = lineFinder(source);
+  const sectionEnds = sections.map((span) => lineAt(span.end));
   const lastLine = source.split("\n").length;
   const matched = findings.map((finding) => ({ finding, suppression: suppressions.find((entry) => covers(entry, finding, sectionEnds, lastLine)) }));
   return {
     kept: matched.filter((entry) => entry.suppression === undefined).map((entry) => entry.finding),
     suppressed: matched.flatMap((entry) => (entry.suppression === undefined ? [] : [{ finding: entry.finding, suppression: entry.suppression }])),
     unusedReasonless: suppressions.filter((entry) => entry.reason === undefined),
+    named: [...new Set(suppressions.flatMap((entry) => entry.rules))],
   };
 };

package/src/structure/aside-depth.ts

@@ -0,0 +1,67 @@
+import type { RelativeVocabulary } from "../plugin.ts";
+
+type Aside = RelativeVocabulary["aside"];
+
+/** 文字と、その位置（UTF-16 の単位で）。絵文字のような 2 単位の文字も 1 文字として読む。 */
+export const characters = (text: string): { readonly char: string; readonly at: number }[] => {
+  const found: { char: string; at: number }[] = [];
+  let at = 0;
+  for (const char of text) {
+    found.push({ char, at });
+    at += char.length;
+  }
+  return found;
+};
+
+/** at の位置で開いたままの括弧書きの開きの位置。text の頭から at まで読む。 */
+export const openAsidesAt = (text: string, at: number, aside: Aside): number[] => {
+  const opens: number[] = [];
+  if (aside === undefined) return opens;
+  characters(text.slice(0, at)).forEach(({ char, at: position }) => {
+    if (char === aside.open) opens.push(position);
+    if (char === aside.close) opens.pop();
+  });
+  return opens;
+};
+
+/** at で開いたままの括弧書きの数（depth）と、一番内側の開きの位置（innermost）。 */
+export type AsideDepth = { readonly depth: (at: number) => number; readonly innermost: (at: number) => number | undefined };
+
+/** 文字の切れ目でない位置（2 単位の文字の途中）の印。 */
+const UNREAD = -2;
+const NO_OPEN = -1;
+
+/**
+ * 本文を一度だけ読み、文字の切れ目ごとに openAsidesAt の答えを覚える。参照ごとに頭から読み直すと、参照の数と行の長さの積になる。
+ * 覚えていない位置（2 単位の文字の途中）は openAsidesAt で読む。
+ */
+export const asideDepth = (text: string, aside: Aside): AsideDepth => {
+  if (aside === undefined) return { depth: () => 0, innermost: () => undefined };
+  const depths = new Int32Array(text.length + 1).fill(UNREAD);
+  const innermosts = new Int32Array(text.length + 1).fill(UNREAD);
+  const opens: number[] = [];
+  depths[0] = 0;
+  innermosts[0] = NO_OPEN;
+  characters(text).forEach(({ char, at }) => {
+    if (char === aside.open) opens.push(at);
+    if (char === aside.close) opens.pop();
+    depths[at + char.length] = opens.length;
+    innermosts[at + char.length] = opens.at(-1) ?? NO_OPEN;
+  });
+  // text.slice(0, at) が切る位置。負の数は後ろから数え、本文の外は端に寄せる。文字の途中なら覚えていない。
+  const cut = (at: number): number => {
+    const whole = Math.trunc(Number.isNaN(at) ? 0 : at);
+    return whole < 0 ? Math.max(text.length + whole, 0) : Math.min(whole, text.length);
+  };
+  return {
+    depth: (at) => {
+      const depth = depths[cut(at)] ?? UNREAD;
+      return depth === UNREAD ? openAsidesAt(text, at, aside).length : depth;
+    },
+    innermost: (at) => {
+      const open = innermosts[cut(at)] ?? UNREAD;
+      if (open === UNREAD) return openAsidesAt(text, at, aside).at(-1);
+      return open === NO_OPEN ? undefined : open;
+    },
+  };
+};