chaffjs 0.16.0 → 0.18.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,6 +11,9 @@ 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 { PatternTimeout } from "./custom/bounded-match.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
 
@@ -68,7 +71,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 +81,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;
@@ -97,7 +109,7 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 /** 要求を満たさない 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;
 };
@@ -112,16 +124,36 @@ const untagged = (rule: RuleDefinition, doc: ProseDocument): string | undefined
 const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefinition[] =>
   rules.filter((rule) => rule.use_for.some((target) => genre.startsWith(target)));
 
+/** rule が品詞か見出し語を要求するか、使えるなら使うか。 */
+export const wantsTags = (rule: RuleDefinition): boolean => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma");
+
 /**
  * 解析器の初期化に払う代金を決める。動く 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((rule) => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma")),
-});
+    .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 how long it ran before a team's pattern was stopped (bounded-match.ts). Other errors are chaff's bugs and propagate. */
+const runDetector = (
+  detector: Detector,
+  doc: ProseDocument,
+  options: DetectorOptions,
+): { readonly findings: readonly Finding[] } | { readonly timedOut: number } => {
+  try {
+    return { findings: detector(doc, options) };
+  } catch (error) {
+    if (error instanceof PatternTimeout) return { timedOut: error.budget_ms };
+    throw error;
+  }
+};
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
   const offset = finding.values["offset"];
@@ -157,6 +189,29 @@ 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[];
+};
+
 export const runRules = (
   doc: ProseDocument,
   rules: readonly RuleDefinition[],
@@ -164,10 +219,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 = [] } = 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);
@@ -188,6 +247,8 @@ export const runRules = (
       // 段階を見た後で聞く。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];
@@ -201,8 +262,14 @@ export const runRules = (
         limit: limitFor(rule, level, genre, limits),
         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 ("timedOut" in ran) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).patternTimeout(ran.timedOut) }] };
+      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: [] },

package/src/semantic.ts

@@ -1,3 +1,5 @@
+import { calendarUnitsOf } from "./calendar-number.ts";
+import { closingAndEarlier, newNumbers } from "./closing-numbers.ts";
 import type { ProseDocument, Section } from "./plugin.ts";
 
 /**
@@ -27,17 +29,23 @@ export const riskDisclosure: Filter = (doc) => {
   return [{ text: body.slice(0, 4000), offset: doc.sentences[0]?.span.start ?? 0 }];
 };
 
-const EVIDENCE = /\d|`|https?:\/\//u;
+const EVIDENCE = /`|https?:\/\//u;
+
+/** 結びに、前に書いていない数があるか。本文の数を繰り返すだけ（「以上のように、9月は…」）なら具体物ではない。 */
+const hasNewNumber = (doc: ProseDocument, last: Section): boolean => {
+  const { closing, earlier } = closingAndEarlier(doc, last);
+  return newNumbers(closing, earlier, calendarUnitsOf(doc)).length > 0;
+};
 
 /**
  * 結びが本文の要約でしかないか。
- * 最後の節だけを見て、そこに具体物が無いときにだけ問い合わせる。
+ * 最後の節だけを見て、そこに具体物（前に書いていない数、コード、リンク）が無いときにだけ問い合わせる。
  */
 export const emptyConclusion: Filter = (doc) => {
   const last = doc.sections.at(-1);
   if (last === undefined || last.sentences.length === 0) return [];
   const text = sectionText(doc, last);
-  if (EVIDENCE.test(text)) return [];
+  if (EVIDENCE.test(text) || hasNewNumber(doc, last)) return [];
   return [{ text: text.slice(0, 2000), offset: last.sentences[0]?.span.start ?? last.span.start }];
 };
 

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,9 @@
 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 { GENRES } from "./genre.ts";
 import { unknownGenres, writtenGenres } from "./genre-check.ts";
 import { loadProfiles } from "./profile/load.ts";
@@ -18,7 +22,9 @@ 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(), ui),
+  ...customRuleProblems(config, ui),
 ];

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/span-merge.ts

@@ -0,0 +1,13 @@
+import type { Span } from "./plugin.ts";
+
+/** 重なる範囲を 1 つにまとめ、始まりの順に並べる。joinTouching なら、接するだけの範囲（前の end が次の start）もまとめる。 */
+export const mergeSpans = (spans: readonly Span[], joinTouching: boolean): Span[] =>
+  spans
+    .toSorted((left, right) => left.start - right.start)
+    .reduce<Span[]>((acc, span) => {
+      const last = acc.at(-1);
+      if (last !== undefined && (joinTouching ? span.start <= last.end : span.start < last.end))
+        acc[acc.length - 1] = { start: last.start, end: Math.max(last.end, span.end) };
+      else acc.push(span);
+      return acc;
+    }, []);

package/src/speaker-labels.ts

@@ -0,0 +1,129 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 戯曲・台本・議事録・書き起こしの、話し手の名前（`ALGERNON.`、行頭の `夫` と全角空白、`○事務局`）。
+ * 名前は誰が話すかの印であって本文ではない。文として数えると、名前だけの文が増え、名前が固有名詞と言い回しの繰り返しに入る。
+ *
+ * 形だけで決める。同じ形の行頭の名前が、MIN_SPEAKERS 人以上それぞれ MIN_TURNS 回以上繰り返され、どれも後に発言が続き、
+ * その形の行が文書の段落の多くを始める。1 つの名前の繰り返しは見出し（○ と全角空白の後の「注意事項」）、
+ * 繰り返されない名前は偶然、ときどき出るだけの `NOTE:` `WARNING:` は注記なので、話し手と読まない。
+ * そう読めた形では、1 度しか話さない人の名前も話し手の名前とする（議事録の委員）。
+ */
+
+/** 話し手と読むのに要る、繰り返す名前の数。 */
+const MIN_SPEAKERS = 2;
+/** 名前が繰り返されたと読む回数。 */
+const MIN_TURNS = 3;
+/** 対話と読むのに要る、その形の行の数。数回の注記（NOTE: と WARNING:）は対話ではない。 */
+const MIN_DIALOGUE_TURNS = 10;
+/** その形の行が始める段落の割合の下限。会議録は長い発言が何段落も続くので、戯曲より低い。 */
+const MIN_TURN_SHARE = 0.1;
+
+type Candidate = { readonly shape: string; readonly name: string; readonly span: Span };
+
+/** 名前の後の発言が、同じ行にあるか（inline）、次の行にあるか（alone）。 */
+type Shape = { readonly id: string; readonly pattern: RegExp; readonly alone: boolean };
+
+/**
+ * 英語の名前は大文字で書いたものだけ（ALGERNON、LADY BRACKNELL、Mr. SMITH）。
+ * 大文字小文字まじりの「Title:」「Notes:」「Content-Type:」は、記録や表の項目の名前と形が同じで、見分けられない。
+ */
+const CAPS_WORD = String.raw`[A-Z][A-Z'’&-]*\.?`;
+const CAPS_NAME = String.raw`(?:[A-Z][a-z]{1,3}\. )?${CAPS_WORD}(?: ${CAPS_WORD}){0,3}`;
+/** 日本語の名前に入らない文字。空白、括弧、句読点、かぎ括弧、コロン。 */
+const JA_NAME = String.raw`[^\s\u3000（）()、。，．「」『』:：]`;
+
+/** 各 pattern の 1 番目の組が行頭の空白、2 番目が覆う範囲、`name` の組が名前。 */
+const SHAPES: readonly Shape[] = [
+  { id: "caps", pattern: new RegExp(String.raw`^(\s*)((?<name>${CAPS_NAME})[.:]?)\s*$`, "u"), alone: true },
+  { id: "caps", pattern: new RegExp(String.raw`^(\s*)((?<name>${CAPS_NAME})[.:])\s+\S`, "u"), alone: false },
+  { id: "mark", pattern: new RegExp(String.raw`^([ \t\u3000]*)([○◯〇](?<name>${JA_NAME}{1,20})(?:（[^）\n]*）)?)[ \t\u3000]*$`, "u"), alone: true },
+  { id: "mark", pattern: new RegExp(String.raw`^([ \t\u3000]*)([○◯〇](?<name>${JA_NAME}{1,20})(?:（[^）\n]*）)?\u3000+)\S`, "u"), alone: false },
+  { id: "spaced", pattern: new RegExp(String.raw`^([ \t]*)((?<name>${JA_NAME}{1,10})\u3000+)\S`, "u"), alone: false },
+  { id: "quote", pattern: new RegExp(String.raw`^([ \t]*)((?<name>${JA_NAME}{1,10}))[ \t]*「`, "u"), alone: false },
+];
+
+/**
+ * 名前でないもの。番号（数字・漢数字・ローマ数字・「第」で始まる序数・1 字の仮名）は見出しや項目の印で、話し手ではない。
+ * 助詞で終わる語は地の文の主語（「私は「…」」）。英字 1 字は、名前より略語や項目の印が多い。
+ */
+const NUMERAL = /^[\d０-９一二三四五六七八九十百千〇IVXLCDM]+(?:の[\d０-９一二三四五六七八九十百千〇]+)*$/u;
+const ORDINAL = /^第[\d０-９一二三四五六七八九十百千〇]/u;
+const DIGIT = /[\d０-９]/u;
+const SINGLE_KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}]$/u;
+const LETTER = /\p{L}/u;
+const PARTICLE_END = /[はがもをにへとでやの]$/u;
+
+const isName = (shape: string, name: string): boolean =>
+  LETTER.test(name) &&
+  !NUMERAL.test(name.replace(/[\s.'’&-]/gu, "")) &&
+  !ORDINAL.test(name) &&
+  !DIGIT.test(name) &&
+  !SINGLE_KANA.test(name) &&
+  !(shape === "quote" && PARTICLE_END.test(name)) &&
+  !(shape === "caps" && name.replace(/[^A-Z]/gu, "").length < 2);
+
+type Line = { readonly start: number; readonly text: string };
+
+const linesOf = (text: string): Line[] => {
+  const scan = { start: 0 };
+  return text.split("\n").map((raw) => {
+    const line = { start: scan.start, text: raw.replace(/\r$/u, "") };
+    scan.start += raw.length + 1;
+    return line;
+  });
+};
+
+const isBlank = (line: Line | undefined): boolean => line === undefined || line.text.trim() === "";
+
+/** 名前だけの行は、次の行に発言があるときだけ話し手の名前（空行の後の大文字の行は見出し）。 */
+const candidateOf = (lines: readonly Line[], index: number): Candidate | undefined => {
+  const line = lines[index];
+  if (line === undefined) return undefined;
+  return SHAPES.flatMap((shape) => {
+    const match = shape.pattern.exec(line.text);
+    const lead = match?.[1];
+    const label = match?.[2];
+    const name = match?.groups?.["name"]?.replace(/[.:]$/u, "");
+    if (lead === undefined || label === undefined || name === undefined || !isName(shape.id, name)) return [];
+    if (shape.alone && isBlank(lines[index + 1])) return [];
+    const start = line.start + lead.length;
+    return [{ shape: shape.id, name, span: { start, end: start + label.length } }];
+  })[0];
+};
+
+const countBy = <T>(items: readonly T[], keyOf: (item: T) => string): Map<string, number> =>
+  items.reduce((counts, item) => counts.set(keyOf(item), (counts.get(keyOf(item)) ?? 0) + 1), new Map<string, number>());
+
+const speakerKey = (candidate: Candidate): string => `${candidate.shape}\n${candidate.name}`;
+
+/** 形ごとに、MIN_TURNS 回以上出る名前が MIN_SPEAKERS 人以上いるか。 */
+const speakerShapes = (candidates: readonly Candidate[]): Set<string> => {
+  const turns = countBy(candidates, speakerKey);
+  const speakers = [...new Map(candidates.map((candidate) => [speakerKey(candidate), candidate])).values()];
+  const repeated = speakers.filter((speaker) => (turns.get(speakerKey(speaker)) ?? 0) >= MIN_TURNS);
+  const perShape = countBy(repeated, (speaker) => speaker.shape);
+  return new Set([...perShape].filter(([, count]) => count >= MIN_SPEAKERS).map(([shape]) => shape));
+};
+
+/** 空行の後から始まる、空でない行のまとまり（段落）の数。 */
+const paragraphCount = (lines: readonly Line[]): number => lines.filter((line, index) => !isBlank(line) && (index === 0 || isBlank(lines[index - 1]))).length;
+
+/** 話し手の形のうち、その形の行が MIN_DIALOGUE_TURNS 以上あり、段落の MIN_TURN_SHARE 以上を始めるもの。 */
+const dialogueShapes = (candidates: readonly Candidate[], paragraphs: number): Set<string> => {
+  const turns = countBy(candidates, (candidate) => candidate.shape);
+  return new Set(
+    [...speakerShapes(candidates)].filter((shape) => {
+      const count = turns.get(shape) ?? 0;
+      return count >= MIN_DIALOGUE_TURNS && count >= paragraphs * MIN_TURN_SHARE;
+    }),
+  );
+};
+
+/** text の中の話し手の名前の範囲。発言は含まない。 */
+export const speakerLabels = (text: string): Span[] => {
+  const lines = linesOf(text);
+  const candidates = lines.flatMap((_, index) => candidateOf(lines, index) ?? []);
+  const shapes = dialogueShapes(candidates, paragraphCount(lines));
+  return candidates.filter((candidate) => shapes.has(candidate.shape)).map((candidate) => candidate.span);
+};

package/src/stray-space.ts

@@ -0,0 +1,81 @@
+// 日本語の語と語のあいだの空白。どの境目を数えるかを品詞で決める。
+import type { Sentence, Span, Token } from "./plugin.ts";
+import { isJapanese } from "./orthography.ts";
+import { isWithinAny, quotedIn } from "./quoted-span.ts";
+
+/** between-phrases は助詞の後ろ（文節の切れ目）、inside-phrase は文節を始められない語の前（助詞・助動詞・名詞に続く「する」）。 */
+export type JointKind = "between-phrases" | "inside-phrase";
+
+/** offset は前の語の終わり（文書の座標）。before / after は境目の両側の語。 */
+export type Joint = { readonly offset: number; readonly kind: JointKind; readonly spaced: boolean; readonly before: string; readonly after: string };
+
+const SPACES = /^[ \u3000]+$/u;
+const PARTICLE = new Set(["ADP", "SCONJ"]);
+// 文節の頭に立てない語。「確認 しました」の「する」は名詞の後ろのときだけ（「し始める」の「し」は動詞の頭に立つ）。
+const BOUND = new Set(["ADP", "SCONJ", "PART", "AUX"]);
+const LIGHT_VERB = "する";
+
+/**
+ * 空白の後ろの「が」を、解析器は文頭の接続詞（「が、」）と読む。一字の接続詞（が・と・や・か）は助詞として扱う。
+ * 二字以上（また・なお）は文節を始める接続詞。
+ */
+const isBound = (token: Token): boolean => BOUND.has(token.pos) || (token.pos === "CCONJ" && [...token.surface].length === 1);
+
+const kindOf = (left: Token, right: Token): JointKind | undefined => {
+  if (isBound(right) || (right.lemma === LIGHT_VERB && left.pos === "NOUN")) return "inside-phrase";
+  // 名詞どうし（担当 田中、赤坂 文弥、フルデスクトップ モード）は名札・名前・複合語の書き方で、数えない。
+  return PARTICLE.has(left.pos) ? "between-phrases" : undefined;
+};
+
+/**
+ * 行（か文）の頭の語か。助詞は前の語に付くので、行頭の「助詞」（「ヘ」）は項目の記号を読み違えたもので、後ろの空白は記号と本文の区切り。
+ * 行頭の内容語（折り返した「確認 しました」の「確認」）は語句の頭なので、ここでは外さない。
+ */
+const isLineHead = (text: string, at: number): boolean => text.slice(text.lastIndexOf("\n", at - 1) + 1, at).trim() === "";
+
+const isWord = (token: Token): boolean => token.surface.trim() !== "";
+
+type Pair = { readonly left: Token; readonly right: Token };
+
+const pairsOf = (tokens: readonly Token[]): Pair[] =>
+  tokens.filter(isWord).flatMap((right, index, words) => {
+    const left = words[index - 1];
+    return left === undefined ? [] : [{ left, right }];
+  });
+
+// 強調とリンクの括弧。読み手には見えない。
+const CHROME = /[*_~[\]]/gu;
+
+/**
+ * 空けたか詰めたか。間が何も無いか強調・リンクの括弧だけなら詰めた、書き手が書いた空白（半角・全角）だけなら空けた。
+ * 括弧の隣の空白（「**…こと** とする」「手順は [README]」）は、日本語の隣で強調が効かない Markdown のための空白なので数えない。
+ * 改行（Markdown の改行や、行の折り返し）や、見える字を覆った空白（コード）をまたぐ語も、境目に数えない。
+ */
+const spacing = (sentence: Sentence, written: string, pair: Pair): boolean | undefined => {
+  const [from, to] = [pair.left.span.end - sentence.span.start, pair.right.span.start - sentence.span.start];
+  const gap = written.slice(from, to);
+  if (gap.replace(CHROME, "") === "") return false;
+  return SPACES.test(gap) ? true : undefined;
+};
+
+const jointOf = (sentence: Sentence, written: string, quoted: readonly Span[], pair: Pair): Joint | undefined => {
+  const { left, right } = pair;
+  if (!isJapanese(left.surface.at(-1)) || !isJapanese(right.surface.at(0))) return undefined;
+  const spaced = spacing(sentence, written, pair);
+  if (spaced === undefined || isWithinAny(quoted, { start: left.span.start, end: right.span.end })) return undefined;
+  const kind = kindOf(left, right);
+  if (kind === undefined || (kind === "between-phrases" && isLineHead(sentence.text, left.span.start - sentence.span.start))) return undefined;
+  return { offset: left.span.end, kind, spaced, before: left.surface, after: right.surface };
+};
+
+/**
+ * 文の中の、日本語の語と語の境目のうち、空けるか詰めるかを数えるもの。written は本文でないものを覆う前の、文と同じ範囲。
+ * 英字・数字との境目は latin-spacing が見るので入れない。
+ */
+export const phraseJoints = (sentence: Sentence, written: string): Joint[] => {
+  const quoted = quotedIn(sentence);
+  return pairsOf(sentence.tokens ?? []).flatMap((pair) => {
+    const joint = jointOf(sentence, written, quoted, pair);
+    return joint === undefined ? [] : [joint];
+  });
+};

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;
+    },
+  };
+};