chaffjs 0.16.0 → 0.17.0

package/src/document.ts

@@ -9,12 +9,13 @@ import { maskSpans } from "./mask.ts";
 import { spansWithin, unmaskedSoftBreaks } from "./soft-break.ts";
 import { segmentJoined } from "./joined-view.ts";
 import { lineParagraphs } from "./line-paragraphs.ts";
+import { speakerLabels } from "./speaker-labels.ts";
 import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
 import { tokenizedLexicons } from "./lexicon-tokens.ts";
 import { inPageAnchors, isInPageNavigation, isNavigationList, type InPageAnchors } from "./in-page-nav.ts";
-import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile, Token } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -204,7 +205,17 @@ const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: Langua
       })),
   );
 
-const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[], strongs: readonly Span[], length: number): Section[] => {
+/** 見出しの語。品詞を読んでいない文書（文が tokens を持たない）では分けない。 */
+const headingTokensOf = (adapter: LanguageAdapter, tagged: boolean, heading: string): { headingTokens?: readonly Token[] } =>
+  tagged && heading !== "" ? { headingTokens: adapter.segment(heading).sentences.flatMap((sentence) => sentence.tokens ?? []) } : {};
+
+const sectionsOf = (
+  headings: readonly Heading[],
+  sentences: readonly Sentence[],
+  strongs: readonly Span[],
+  length: number,
+  tokensOf: (heading: string) => { headingTokens?: readonly Token[] },
+): Section[] => {
   const bounds = headings.map((heading, index) => ({ heading, from: heading.end, to: headings[index + 1]?.start ?? length }));
   const lead = { heading: { depth: 0, text: "", start: 0, end: 0 }, from: 0, to: headings[0]?.start ?? length };
   return [lead, ...bounds]
@@ -214,6 +225,7 @@ const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[]
       return {
         depth: heading.depth,
         heading: heading.text,
+        ...tokensOf(heading.text),
         span: { start: from, end: to },
         sentences: inside,
         strongCount: strongs.filter((span) => within(span, from, to)).length,
@@ -290,6 +302,15 @@ export const teamRules = (config: {
   names: config.names ?? [],
 });
 
+/**
+ * masked を覆った本文から、話し手の名前（戯曲・議事録）も覆う。名前は誰が話すかの印で、文でも本文でもない。
+ * 名前は覆った後の本文で探す。コードや表の中の行頭を話し手と数えない。
+ */
+const proseOf = (source: string, masked: readonly Span[]): string => {
+  const unlabelled = maskSpans(source, masked);
+  return maskSpans(unlabelled, speakerLabels(unlabelled));
+};
+
 export const buildDocument = (
   path: string,
   source: string,
@@ -304,7 +325,7 @@ export const buildDocument = (
   // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
   const blocks = [...collectMasks(root, source, anchors), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
   const masked = [...blocks, ...emphasisSpans(root, source)];
-  const prose = maskSpans(source, masked);
+  const prose = proseOf(source, masked);
   // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
   const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   const listItems = spansOfType(root, "listItem");
@@ -327,7 +348,7 @@ export const buildDocument = (
     language: adapter.id,
     lengthUnit: adapter.capabilities.lengthUnit,
     capabilities: adapter.capabilities,
-    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length),
+    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length, (heading) => headingTokensOf(adapter, tagged, heading)),
     sentences,
     listSpans: listItems,
     paragraphs: paragraphsOf(prose, paragraphSpans, sentences, listItems),

package/src/genre-parse.ts

@@ -20,8 +20,17 @@ export type GenreDefinition = {
 /** A line shape that marks the genre, and how many lines must have it. */
 type LineCue = { readonly line: RegExp; readonly minLines: number };
 
-/** What makes a document look like this genre when no genre is set: its path, or enough lines of the genre's own shape, per language. */
-export type GenreSuggest = { readonly paths: readonly RegExp[]; readonly lines: Readonly<Record<string, LineCue>> };
+/**
+ * What makes a document look like this genre when no genre is set: its path, or per language, the shape of the body's first
+ * line (a letter's salutation) or enough lines of the genre's own shape.
+ */
+export type GenreSuggest = {
+  readonly paths: readonly RegExp[];
+  readonly lines: Readonly<Record<string, LineCue>>;
+  readonly openings: Readonly<Record<string, RegExp>>;
+};
+
+type LanguageCue = { readonly line: LineCue | undefined; readonly opening: RegExp | undefined };
 
 export type GenreData = { readonly groups: readonly GenreGroup[]; readonly genres: readonly GenreDefinition[] };
 
@@ -71,15 +80,31 @@ const lineCueOf = (value: unknown, where: string): LineCue => {
   return { line: patternOf(value["line"], "u", where), minLines };
 };
 
+const hasLineCue = (value: Readonly<Record<string, unknown>>): boolean => value["line"] !== undefined || value["min_lines"] !== undefined;
+
+const languageCueOf = (value: unknown, where: string): LanguageCue => {
+  if (!isRecord(value) || (!hasLineCue(value) && value["opening"] === undefined)) throw new Error(`${where}: needs line and min_lines, or opening`);
+  return {
+    line: hasLineCue(value) ? lineCueOf(value, where) : undefined,
+    opening: value["opening"] === undefined ? undefined : patternOf(value["opening"], "u", where),
+  };
+};
+
+const presentOf = <T>(cues: readonly (readonly [string, T | undefined])[]): Record<string, T> =>
+  Object.fromEntries(cues.filter((entry): entry is readonly [string, T] => entry[1] !== undefined));
+
 const suggestOf = (value: unknown, where: string): GenreSuggest => {
-  if (value === undefined) return { paths: [], lines: {} };
+  if (value === undefined) return { paths: [], lines: {}, openings: {} };
   if (!isRecord(value)) throw new Error(`${where}: suggest must be a map`);
   const paths = value["paths"] ?? [];
   if (!Array.isArray(paths)) throw new Error(`${where}: suggest.paths must be a list`);
-  const lines = Object.entries(value).filter(([key]) => key !== "paths");
+  const cues = Object.entries(value)
+    .filter(([key]) => key !== "paths")
+    .map(([language, cue]) => [language, languageCueOf(cue, `${where} suggest.${language}`)] as const);
   return {
     paths: paths.map((path) => patternOf(path, "iu", `${where} suggest.paths`)),
-    lines: Object.fromEntries(lines.map(([language, cue]) => [language, lineCueOf(cue, `${where} suggest.${language}`)])),
+    lines: presentOf(cues.map(([language, cue]) => [language, cue.line] as const)),
+    openings: presentOf(cues.map(([language, cue]) => [language, cue.opening] as const)),
   };
 };
 

package/src/genre-suggest.ts

@@ -1,4 +1,5 @@
 import type { GenreData, GenreDefinition } from "./genre-parse.ts";
+import { openingLine } from "./opening-line.ts";
 import { detected, type ProfileDefinition } from "./profile/parse.ts";
 
 /** The file a genre is suggested for: where it is, what it says, and its language. */
@@ -7,6 +8,15 @@ export type SuggestInput = { readonly path: string; readonly source: string; rea
 /** A path cue names the kind outright, so it outweighs any count of lines. */
 const BY_PATH = Number.POSITIVE_INFINITY;
 
+/** How the body opens (Dear ..., 拝啓) says what the document is even when it encloses another kind; a path still says more. */
+const BY_OPENING = Number.MAX_VALUE;
+
+const opensAs = (genre: GenreDefinition, input: SuggestInput): boolean => {
+  const opening = genre.suggest.openings[input.language];
+  const first = openingLine(input.source);
+  return opening !== undefined && first !== undefined && opening.test(first);
+};
+
 /** How many times over the genre's lines reach their minimum: 1 is just enough, 0 is none of that shape. */
 const linesScore = (genre: GenreDefinition, input: SuggestInput): number => {
   const cue = genre.suggest.lines[input.language];
@@ -20,8 +30,11 @@ const profileScore = (genre: GenreDefinition, input: SuggestInput, profiles: rea
   return profile !== undefined && detected(profile, input.source, input.language) ? 1 : 0;
 };
 
-const scoreOf = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number =>
-  genre.suggest.paths.some((pattern) => pattern.test(input.path)) ? BY_PATH : Math.max(linesScore(genre, input), profileScore(genre, input, profiles));
+const scoreOf = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number => {
+  if (genre.suggest.paths.some((pattern) => pattern.test(input.path))) return BY_PATH;
+  if (opensAs(genre, input)) return BY_OPENING;
+  return Math.max(linesScore(genre, input), profileScore(genre, input, profiles));
+};
 
 type Scored = { readonly genre: GenreDefinition; readonly score: number };
 

package/src/line-paragraphs.ts

@@ -51,6 +51,9 @@ const firstStartingAt = (cores: readonly Span[], offset: number): number => {
 /** 改行をまたぐ文が無い。またぐなら、改行の直前に始まった文がまだ続いている。 */
 const endsSentence = (line: Line, cores: readonly Span[]): boolean => (cores[firstStartingAt(cores, line.newline) - 1]?.end ?? 0) <= line.newline;
 
+/** 覆われて空白だけになった行（話し手の名前の行）は段落を終えない。終えると、文の無い段落ができる。 */
+const hasText = (source: string, line: Line): boolean => source.slice(line.span.start, line.span.end).trim().length > 0;
+
 /** 行の並びを、文の終わる改行で区切った段落。 */
 const groupAt = (lines: readonly Line[], closing: readonly boolean[]): Span[] => {
   const firsts = lines.flatMap((_, index) => (index === 0 || closing[index - 1] === true ? [index] : []));
@@ -77,7 +80,7 @@ const isLineShaped = (lines: readonly Line[], closing: readonly boolean[], group
 export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] => {
   const lines = linesOf(source, paragraph);
   const cores = sentences.map((sentence) => coreOf(source, sentence)).filter((core) => core.end > core.start);
-  const closing = lines.map((line) => endsSentence(line, cores));
+  const closing = lines.map((line) => hasText(source, line) && endsSentence(line, cores));
   const groups = groupAt(lines, closing);
   return isLineShaped(lines, closing, groups, cores) ? groups : [paragraph];
 };

package/src/mask.ts

@@ -1,4 +1,5 @@
 import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
 
 /**
  * 非 prose（コードブロック・インラインコード・表・見出し・URL）を、
@@ -16,18 +17,8 @@ import type { Span } from "./plugin.ts";
  */
 const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
-const merge = (spans: readonly Span[]): Span[] =>
-  spans
-    .toSorted((left, right) => left.start - right.start)
-    .reduce<Span[]>((acc, span) => {
-      const last = acc.at(-1);
-      if (last !== undefined && span.start <= last.end) acc[acc.length - 1] = { start: last.start, end: Math.max(last.end, span.end) };
-      else acc.push(span);
-      return acc;
-    }, []);
-
 export const maskSpans = (source: string, spans: readonly Span[]): string => {
-  const merged = merge(spans);
+  const merged = mergeSpans(spans, true);
   const { parts, cursor } = merged.reduce<{ parts: string[]; cursor: number }>(
     (acc, span) => ({
       parts: [...acc.parts, source.slice(acc.cursor, span.start), blankOut(source.slice(span.start, span.end))],

package/src/number-name.ts

@@ -88,7 +88,7 @@ export const placeChainBefore = (tokens: readonly Token[], end: number): Token[]
  * ハイフンの無い数（千代田区23 番）も読まない。topUnits は都道府県の単位（語彙表 prefecture-unit）。
  */
 const isAddressNumber = (text: string, run: Span, tokens: readonly Token[], base: number, topUnits: ReadonlySet<string>): boolean =>
-  [...text.slice(run.start, run.end)].some(isHyphen) &&
+  Array.from(text.slice(run.start, run.end)).some(isHyphen) &&
   placeChainBefore(tokens, base + run.start).some((token) => isGeoUnit(token) && !topUnits.has(token.surface));
 
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */

package/src/opening-line.ts

@@ -0,0 +1,17 @@
+import { plainSource } from "./plain-source.ts";
+
+const FRONT_MATTER_FENCE = "---";
+/** An ATX heading; four spaces of indent make it a code line instead. */
+const HEADING = /^ {0,3}#{1,6}(?:\s|$)/u;
+
+/** The lines after a leading front matter block. */
+const bodyLines = (lines: readonly string[]): readonly string[] => {
+  const close = lines[0] === FRONT_MATTER_FENCE ? lines.indexOf(FRONT_MATTER_FENCE, 1) : -1;
+  return close === -1 ? lines : lines.slice(close + 1);
+};
+
+/** The line a document's body opens with (a letter's salutation), past front matter, blank lines and Markdown headings. */
+export const openingLine = (source: string): string | undefined =>
+  bodyLines(plainSource(source).split("\n"))
+    .find((line) => line.trim() !== "" && !HEADING.test(line))
+    ?.trim();

package/src/orthography.ts

@@ -2,6 +2,14 @@
 
 export const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 
+/**
+ * 字に挟まれた ’ と、どこにあっても ʼ を ' にする（don’t → don't）。語彙表は ' で書くので、’ で書いた本文も同じ語に当てるため。
+ * 英語アダプタの解析器が同じ決めかたをする（chaff とアダプタは実行時の値を共有しないので、ここにも置く）。一字を一字に置き換えるので位置は変わらない。
+ */
+const APOSTROPHE = /(?<=[\p{L}\p{N}])’(?=\p{L})|ʼ/gu;
+
+export const straightApostrophes = (text: string): string => text.replace(APOSTROPHE, "'");
+
 /** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
 const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
   const pattern = new RegExp(escapeRegExp(word), ignoreCase ? "giu" : "gu");
@@ -55,7 +63,7 @@ const kindOf = (char: string | undefined, digitSide: "before-digit" | "after-dig
   return DIGIT.test(char) ? digitSide : undefined;
 };
 
-const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
+export const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
 
 /** japanese が日本語の字のとき、other の英字・数字の種類。 */
 const latinBeside = (japanese: string | undefined, other: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined =>
@@ -189,7 +197,7 @@ export const latinBoundaries = (text: string, written: string = text): Boundary[
  * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
  * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
  */
-export const minorityStyle = (boundaries: readonly Boundary[]): boolean | undefined => {
+export const minorityStyle = (boundaries: readonly { readonly spaced: boolean }[]): boolean | undefined => {
   const spaced = boundaries.filter((boundary) => boundary.spaced).length;
   const touching = boundaries.length - spaced;
   if (spaced === 0 || touching === 0) return undefined;

package/src/paragraph-length.ts

@@ -0,0 +1,9 @@
+/**
+ * 段落が長すぎるか。文の数が上限を超え、しかも長さが「上限の数だけ普通の長さの文を並べた長さ」を超えるときだけ。
+ * 短い文をいくつ並べても、読み手が息をつけない壁にはならない。長さは adapter の単位（日本語は文字、英語は語）。
+ * fullSentence が無ければ、文の数だけで決める。
+ */
+export const isTooLongParagraph = (sentenceSizes: readonly number[], limit: number, fullSentence: number | undefined): boolean => {
+  const size = sentenceSizes.reduce((sum, sentence) => sum + sentence, 0);
+  return sentenceSizes.length > limit && (fullSentence === undefined || size > limit * fullSentence);
+};

package/src/plugin.ts

@@ -204,6 +204,8 @@ export type Section = {
   /** 見出しの深さ。見出しより前の導入部は 0。 */
   readonly depth: number;
   readonly heading: string;
+  /** 見出しを文と同じ解析器で語に分けたもの。文が tokens を持つときだけ入る。 */
+  readonly headingTokens?: readonly Token[];
   readonly span: Span;
   readonly sentences: readonly Sentence[];
   /** この節に含まれる強調（Markdown の ** **）の数。 */
@@ -346,6 +348,8 @@ export type DetectorOptions = {
   readonly lexicon?: Lexicon | undefined;
   /** 見る範囲。opening は冒頭 2 段落、closing は最後の節、whole は全体。 */
   readonly where?: string | undefined;
+  /** 普通の長さの文 1 つの長さ（adapter の単位）。段落の長さを文の数と一緒に見る rule だけが持つ。 */
+  readonly fullSentence?: number | undefined;
 };
 
 export type Detector = (doc: ProseDocument, options: DetectorOptions) => Finding[];
@@ -378,6 +382,8 @@ export type RuleDefinition = {
   /** L4 のみ。LLM に渡す決まり。言語別。 */
   readonly what_to_check: Localized | undefined;
   readonly where: string | undefined;
+  /** 普通の長さの文 1 つの長さ。言語で単位が違うので、levels と同じく読み込み時に言語で平坦化済み。 */
+  readonly full_sentence: number | undefined;
   /** adapter に要る capability。"pos" / "lemma"。満たさなければ動かさない。spec §16。 */
   readonly requires: readonly string[];
   /** 使えるなら用意してほしい capability（"pos"）。requires と違い、満たせなくても動かす（品詞が無ければ文字だけで見る）。 */

package/src/quoted-span.ts

@@ -4,7 +4,7 @@ import type { Sentence, Span } from "./plugin.ts";
 type Marks = Readonly<Record<string, string>>;
 
 /** 鉤括弧。日本語の引用と題名。 */
-export const KAGI_MARKS: Marks = { "「": "」", "『": "』" };
+const KAGI_MARKS: Marks = { "「": "」", "『": "』" };
 
 /**
  * 引用符も含めた、人の言葉を引く印。英語の "…" は開きと閉じが同じ字なので、開いている間に来たら閉じと読む。

package/src/rule-load.ts

@@ -83,6 +83,13 @@ const severityOf = (raw: unknown, language: string): Severity => {
   return isSeverity(picked) ? picked : "warning";
 };
 
+/** 言語で単位が違う数（日本語は文字、英語は語）。その言語のぶんだけを取る。無い言語では undefined。 */
+const numberFor = (raw: unknown, language: string): number | undefined => {
+  if (typeof raw === "number") return raw;
+  const picked: unknown = isRecord(raw) ? (raw[language] ?? raw["default"]) : undefined;
+  return typeof picked === "number" ? picked : undefined;
+};
+
 const stringList = (value: unknown): string[] | undefined => (Array.isArray(value) ? value.map((entry) => String(entry)) : undefined);
 
 const toRule = (raw: unknown, language: string, file: string): RuleDefinition => {
@@ -107,6 +114,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     extra_word_lists: stringList(raw["extra_word_lists"]) ?? [],
     what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
+    full_sentence: numberFor(raw["full_sentence"], language),
     requires: stringList(raw["requires"]) ?? [],
     uses: stringList(raw["uses"]) ?? [],
     from: stringList(raw["from"]) ?? [],

package/src/run-semantic.ts

@@ -3,8 +3,9 @@ import { ask, type JudgeOptions } from "./judge.ts";
 import { FILTERS, type Candidate } from "./semantic.ts";
 import { narrow, type Narrowing } from "./look-at.ts";
 import { localized } from "./render/text.ts";
-import type { Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
+import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
+import { wantsTags } from "./run.ts";
 
 export type SemanticResult = {
   readonly findings: readonly Finding[];
@@ -39,26 +40,33 @@ const severityFromLevel = (rule: RuleDefinition, level: Level): Severity => {
   return SEVERITY_BY_VALUE[Math.min(3, Math.max(1, Math.round(value)))] ?? "warning";
 };
 
+/** この文書で動かす、意味を読む rule。 */
+const semanticRules = (rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): RuleDefinition[] =>
+  rules.filter((rule) => rule.layer === "L4" && rule.use_for.some((target) => genre.startsWith(target)) && settings[rule.id] !== "off");
+
+/** 意味を読む rule の絞り込みが品詞を使うか。chaff test はこれで解析器を読み込む（neededBy は L4 を数えない）。 */
+export const semanticNeeds = (rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): AdapterNeeds => ({
+  pos: semanticRules(rules, settings, genre).some(wantsTags),
+});
+
 const builtInJobs = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): Job[] =>
-  rules
-    .filter((rule) => rule.layer === "L4" && rule.use_for.some((target) => genre.startsWith(target)) && settings[rule.id] !== "off")
-    .flatMap((rule) => {
-      const rubric = rule.what_to_check === undefined ? undefined : localized(rule.what_to_check, doc.language);
-      if (rubric === undefined || rubric.length === 0) return [];
-      // 絞り込みが無い rule は動かさない。黙って落とさず、下の skipped に出す。
-      const filter = filterFor(rule.how_to_find);
-      if (filter === undefined) return [];
-      return [
-        {
-          rule: rule.id,
-          name: localized(rule.name, doc.language),
-          rubric,
-          howToFix: localized(rule.how_to_fix, doc.language),
-          severity: severityFromLevel(rule, settings[rule.id] ?? "normal"),
-          candidates: filter(doc),
-        },
-      ];
-    });
+  semanticRules(rules, settings, genre).flatMap((rule) => {
+    const rubric = rule.what_to_check === undefined ? undefined : localized(rule.what_to_check, doc.language);
+    if (rubric === undefined || rubric.length === 0) return [];
+    // 絞り込みが無い rule は動かさない。黙って落とさず、下の skipped に出す。
+    const filter = filterFor(rule.how_to_find);
+    if (filter === undefined) return [];
+    return [
+      {
+        rule: rule.id,
+        name: localized(rule.name, doc.language),
+        rubric,
+        howToFix: localized(rule.how_to_fix, doc.language),
+        severity: severityFromLevel(rule, settings[rule.id] ?? "normal"),
+        candidates: filter(doc),
+      },
+    ];
+  });
 
 const userJobs = (doc: ProseDocument, checks: readonly UserCheck[], genre: string): Job[] =>
   checks

package/src/run.ts

@@ -112,6 +112,9 @@ 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 は「払えばできる」の宣言なので、ここでは見ない。
@@ -120,7 +123,7 @@ export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, e
   pos: 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")),
+    .some(wantsTags),
 });
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
@@ -201,6 +204,7 @@ 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,
       };
       const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
       return { findings: [...acc.findings, ...found], skipped: acc.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/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);
+};