chaffjs 0.13.0 → 0.15.0

package/src/detectors/signals.ts

@@ -3,7 +3,11 @@ import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
 import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
 import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
-import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import { isExplained } from "./acronym-compound.ts";
+import { conjugatedForms } from "./conjugated-form.ts";
+import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { hasPredicateIn } from "./gram-predicate.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -97,29 +101,15 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
 /** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
 const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
 
-/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
-const PREDICATE_POS = new Set(["VERB", "AUX"]);
-
-const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
-
-/**
- * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
- * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
- */
-const modifiesNoun = (tokens: readonly Token[], index: number, unit: ProseDocument["lengthUnit"]): boolean =>
-  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
-
 /**
- * 語句が文の中で占める範囲に、動詞か助動詞があるか。範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
  */
 const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
   if (sentence.tokens === undefined) return true;
   const place = placeOf(compacted(sentence.text, unit), gram);
   if (place === undefined) return true;
-  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
-  const tokens = sentence.tokens;
-  return tokens.some((token, index) => PREDICATE_POS.has(token.pos) && token.span.start < end && start < token.span.end && !modifiesNoun(tokens, index, unit));
+  return hasPredicateIn(sentence.tokens, { start: sentence.span.start + place.start, end: sentence.span.start + place.end }, unit);
 };
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
@@ -149,10 +139,14 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
  * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
  *
  * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
+ * - で繋いだ略語どうしも 1 語（RT-PCR）。割ると RT が別の略語に見える。数字を含むもの（COVID-19）は識別子として外す。
  */
 const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
 const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
-const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,6})${EDGE_AFTER}`, "gu");
+/** 略語として読む大文字の長さの上限。これより長い大文字の語（BILLING）は、普通の語を大文字で書いたもの。 */
+const ACRONYM_MAX = 6;
+const ACRONYM_PART = String.raw`(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,${ACRONYM_MAX}})`;
+const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}${ACRONYM_PART}(?:-${ACRONYM_PART})*${EDGE_AFTER}`, "gu");
 
 /**
  * 大文字で書かれていても略語ではないもの。
@@ -161,9 +155,17 @@ const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{
  * 強調は読点や括弧をまたいで続くので（THE AUTHOR, THE COMPANY (IF ANY)）、そういう続きを含む
  * 「大文字以外の文字を含まない一続き」を丸ごと強調と見なす。小文字の語が挟まれば切れるので、
  * 「SRE, SLO, MTTR」のような略語の並びは残る。引用符に包まれた大文字の句（“AS IS”）も強調。
+ * 2 語でも、片方が略語にしては長い語なら強調（BILLING CODE）。略語 2 つの並び（NIST SP）は残る。
  */
 const CAPS_WORD = String.raw`[A-Z]+(?:&[A-Z]+)*`;
-const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:[\s"“”'‘’]+${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+const LONG_CAPS_WORD = String.raw`[A-Z]{${ACRONYM_MAX + 1},}`;
+const CAPS_GAP = String.raw`[\s"“”'‘’]+`;
+const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:${CAPS_GAP}${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+/** 2 語の強調は、その 2 語だけを外す。続きまで外すと、区切りの後ろの略語（NEW GUIDELINES: SRE）まで消える。 */
+const SHOUTED_PAIR = new RegExp(
+  String.raw`${EDGE_BEFORE}(?:${LONG_CAPS_WORD}${CAPS_GAP}${CAPS_WORD}|${CAPS_WORD}${CAPS_GAP}${LONG_CAPS_WORD})${EDGE_AFTER}`,
+  "gu",
+);
 const UNCASED_STRETCH = /(?:[A-Z]|\P{L})+/gu;
 const QUOTED_CAPS = new RegExp(String.raw`["“'‘]${CAPS_WORD}(?:\s+${CAPS_WORD})+["”'’]`, "gu");
 
@@ -186,7 +188,7 @@ const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: mat
 const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
   ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
   ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
-  ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
+  ...[SHOUTED_PAIR, QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
   ...notation(text),
 ];
 
@@ -216,17 +218,28 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     currencies: patternsOf(doc, "currency-code"),
     usStates: patternsOf(doc, "us-state-code"),
     emphasis: patternsOf(doc, "emphasis-word"),
+    divisions: patternsOf(doc, "numbered-division"),
+    honorifics: patternsOf(doc, "honorific"),
+    dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
 
+/** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
+const definitionVerbsOf = (doc: ProseDocument): string[] => {
+  const verbs = patternsOf(doc, "definition-verb");
+  return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
+};
+
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
-  const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
+  // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
+  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method")]);
   const seen = new Map<string, Hit>();
   acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
-    if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
+    if (!seen.has(word)) seen.set(word, hit);
   });
-  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: patternsOf(doc, "definition-verb") });
-  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym, expandedAt));
+  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
+  const explainedAlone = (word: string): boolean => common.has(word) || isExpanded(body, word, expandedAt);
+  const bare = [...seen.entries()].filter(([acronym]) => !isExplained(acronym, explainedAlone));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",
@@ -257,16 +270,16 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
   return pieces.length <= OPENING[unit] ? pieces.join(joiner) : `${pieces.slice(0, OPENING[unit]).join(joiner)}…`;
 };
 
-/**
- * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
- * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。品詞が無ければ、数字だけを見る。
- */
-const hasNumeral = (section: Section): boolean =>
-  section.sentences.some((sentence) => (sentence.tokens ?? []).some((token) => token.features?.["NumType"] === "Card"));
+const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const sections = doc.sections.filter((section) => section.sentences.length >= 3);
-  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeral(section));
+  const bare = sections.filter(
+    (section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeralIn(section) && !startsWithin(section.span, doc.links),
+  );
+  // 構造の木は作るのに手間がかかる。指摘に届かない文書では作らない。
+  const nodes = bare.length < options.limit ? [] : evidenceSpans(doc.structure);
+  const empty = bare.filter((section) => !startsWithin(section.span, nodes));
   if (empty.length < options.limit) return [];
   return empty.map((section) => ({
     rule: "concrete-evidence-density",

package/src/detectors/structure-tree.ts

@@ -17,11 +17,11 @@ const quoteAt = (source: string, offset: number): string => {
 };
 
 const findingsOf =
-  (rule: string, issuesOf: (tree: NonNullable<ProseDocument["structure"]>) => StructureIssue[]): Detector =>
+  (rule: string, issuesOf: (tree: NonNullable<ProseDocument["structure"]>, source: string) => StructureIssue[]): Detector =>
   (doc): Finding[] =>
     doc.structure === undefined
       ? []
-      : issuesOf(doc.structure).map((issue) => ({
+      : issuesOf(doc.structure, doc.source).map((issue) => ({
           rule,
           severity: "error",
           line: 0,

package/src/detectors/structure.ts

@@ -2,6 +2,7 @@ import { charLength, lengthOf } from "../measure.ts";
 import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
 import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
+import { preambleParagraphs } from "../preamble-paragraphs.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -116,7 +117,7 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = doc.sections.find((section) => section.depth >= 2);
   if (body === undefined) return [];
-  const all = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  const all = preambleParagraphs(doc.paragraphs, body.span.start);
   if (all.length <= options.limit) return [];
   const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];

package/src/detectors/superlative-name.ts

@@ -0,0 +1,30 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 記号（最高!）は名詞と付いても語を作らない。 */
+const LETTER = /\p{L}/u;
+
+const joinsAsNoun = (previous: Token, token: Token | undefined): token is Token =>
+  token !== undefined && token.pos === "NOUN" && LETTER.test(token.surface) && previous.span.end === token.span.start;
+
+/** 空白も助詞も挟まずに続く名詞の連なり（最大|瞬間|風速）の最後の語。連なりが無ければ undefined。 */
+const lastJoined = (tokens: readonly Token[], at: number): Token | undefined => {
+  const previous = tokens[at - 1];
+  const token = tokens[at];
+  if (previous === undefined || !joinsAsNoun(previous, token)) return undefined;
+  return lastJoined(tokens, at + 1) ?? token;
+};
+
+const measures = (noun: Token, quantities: Lexicon): boolean => quantities.some((entry) => entry.pattern === noun.surface);
+
+/**
+ * 最上級の名詞がそのまま名詞と 1 語になり、その連なりが測る量の名詞で終わるか（最大風速・最高気温・最大値・最大駐車台数）。
+ * これは量の名前で、何かが一番だという主張ではない。「最大の効果」「最も速い」は助詞や用言を挟むので当たらない。
+ * ほかの名詞で終わる語（最高品質・最高精度・最大効果）は一番だという主張のまま。量の名詞は言語パッケージの語彙表が持つ。
+ */
+export const namesQuantity = (tokens: readonly Token[], range: TokenRange, quantities: Lexicon): boolean => {
+  const superlative = tokens[range.start];
+  const single = range.end - range.start === 1 && superlative?.pos === "NOUN";
+  const last = single ? lastJoined(tokens, range.end) : undefined;
+  return last !== undefined && measures(last, quantities);
+};

package/src/detectors/token-shape.ts

@@ -1,5 +1,6 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
-import type { Detector, Finding, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
@@ -57,17 +58,25 @@ const BREAK: Run = { surface: "", tokens: [] };
 /**
  * 名詞は連なりの中身なので飛ばす。読点と、語彙表に無い助詞は連なりを切る。
  * 「弊社のAはBの」を 2 回続いたと数えないため。「は」でいちど句が閉じている。
+ *
+ * 鉤括弧で引いたもの（括弧ごと）は、名詞と同じく連なりの中身として飛ばす。引いた題名（「食品中のウイルスの制御のための…ガイドライン」）や
+ * 発言は書き手が言い換えられないので、中の助詞は数えない。題名も名前なので、外の連なり（弊社の「新製品」の販売の計画）は続けて数える。
  */
-const runsOf = (tokens: readonly Token[], nesting: readonly string[]): Run[] =>
+const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: readonly Span[]): Run[] =>
   tokens.reduce<Run[]>((acc, token) => {
+    if (isWithinAny(quoted, token.span)) return acc;
     if (nesting.includes(token.surface)) return extend(acc, token);
     return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
   }, []);
 
+/** 文の中の、鉤括弧で引いたものを括弧ごと、文書全体の座標で。 */
+const quotedIn = (sentence: Sentence): Span[] =>
+  quotedSpans(sentence.text).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
+
 export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
   return doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], nesting)
+    runsOf(sentence.tokens ?? [], nesting, quotedIn(sentence))
       .filter((run) => run.tokens.length > options.limit)
       .map((run) => ({
         rule: "no-doubled-joshi",

package/src/document.ts

@@ -6,6 +6,8 @@ import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
 import { hasTitle } from "./heading-title.ts";
 import { maskSpans } from "./mask.ts";
+import { spansWithin, unmaskedSoftBreaks } from "./soft-break.ts";
+import { segmentJoined } from "./joined-view.ts";
 import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
@@ -187,15 +189,17 @@ const spansOfType = (root: Node, type: string, keep: (node: Node) => boolean = (
  */
 const shift = (span: Span, by: number): Span => ({ start: by + span.start, end: by + span.end });
 
-const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter): Sentence[] =>
+const breaksWithin = (breaks: readonly Span[], paragraph: Span): Span[] => spansWithin(breaks, paragraph).map((span) => shift(span, -paragraph.start));
+
+const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter, softBreaks: readonly Span[]): Sentence[] =>
   paragraphs.flatMap((paragraph) =>
-    adapter
-      .segment(prose.slice(paragraph.start, paragraph.end))
-      .sentences.filter((sentence) => sentence.text.trim().length > 0)
+    segmentJoined(prose.slice(paragraph.start, paragraph.end), breaksWithin(softBreaks, paragraph), (text) => adapter.segment(text))
+      .filter((sentence) => sentence.text.trim().length > 0)
       .map((sentence) => ({
         span: shift(sentence.span, paragraph.start),
         text: sentence.text,
         ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map((token) => ({ ...token, span: shift(token.span, paragraph.start) })) }),
+        ...(sentence.wrapBreaks === undefined ? {} : { wrapBreaks: sentence.wrapBreaks.map((span) => shift(span, paragraph.start)) }),
       })),
   );
 
@@ -279,7 +283,9 @@ export const buildDocument = (
   // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
   const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   const listItems = spansOfType(root, "listItem");
-  const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  // Markdown は段落を流し込んで表示するので、段落の中の改行は読み手に見えない。テキストの文書は行をそのまま見せる（法令は 1 行 1 号）。
+  const softBreaks = isMarkdownPath(path) ? unmaskedSoftBreaks(source, prose) : [];
+  const sentences = sentencesOf(prose, paragraphSpans, adapter, softBreaks);
   const lexicons = {
     ...adapter.lexicons,
     "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
@@ -301,6 +307,7 @@ export const buildDocument = (
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source, anchors),
+    links: [...spansOfType(root, "link"), ...spansOfType(root, "linkReference")],
     lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。

package/src/genre-check.ts

@@ -0,0 +1,46 @@
+import { frontMatterValues } from "./genre.ts";
+
+/** Where a genre was set: the command line, chaff.yaml's genre, or one of its by_path entries. */
+export type GenreSetting = "--genre" | "config" | "by_path";
+
+type UnknownGenre = {
+  readonly where: GenreSetting;
+  readonly genre: string;
+  /** The by_path entry's files, so the message can say which entry; empty elsewhere. */
+  readonly files: readonly string[];
+};
+
+type PathGenre = { readonly files: readonly string[]; readonly genre: string | undefined };
+
+type WrittenGenres = { readonly flag: string | undefined; readonly config: string | undefined; readonly byPath: readonly PathGenre[] };
+
+/** Commands that never read a genre from chaff.yaml. A wrong one there must not stop them: genres is how to find the right name. */
+const GENRE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off", "tree", "cite"]);
+
+/** The genres a command would read: --genre always (every command refuses a wrong one), chaff.yaml's only where the command reads a genre. */
+export const writtenGenres = (
+  command: string,
+  flag: string | undefined,
+  config: { readonly genre: string | undefined; readonly byPath: readonly PathGenre[] },
+): WrittenGenres => (GENRE_FREE.has(command) ? { flag, config: undefined, byPath: [] } : { flag, config: config.genre, byPath: config.byPath });
+
+const setting = (where: GenreSetting, genre: string | undefined, files: readonly string[] = []): UnknownGenre[] =>
+  genre === undefined ? [] : [{ where, genre, files }];
+
+/**
+ * Every genre a setting names that chaff does not know: no rule's use_for matches one, so nothing would run and nothing be listed as not run.
+ * All of them, not only the one a file would use, because a wrong setting is wrong for every file.
+ */
+export const unknownGenres = (written: WrittenGenres, known: readonly string[]): UnknownGenre[] =>
+  [
+    ...setting("--genre", written.flag),
+    ...setting("config", written.config),
+    ...written.byPath.flatMap((entry) => setting("by_path", entry.genre, entry.files)),
+  ].filter((entry) => !known.includes(entry.genre));
+
+/**
+ * The front matter's genre that was not read. Front matter is the document's and often another tool's, so this warns and does not stop:
+ * the file falls back to the path, the content or the default. type is not looked at (Zenn's tech / idea mean something else).
+ */
+export const unknownFrontMatterGenre = (source: string, known: readonly string[]): string | undefined =>
+  frontMatterValues(source, "genre").find((value) => value !== "" && !known.includes(value));

package/src/genre.ts

@@ -1,3 +1,17 @@
+/** chaff が知っているジャンル。rule の use_for はこの頭の部分で当てる。 */
+export const GENRES: readonly string[] = [
+  "technical/spec",
+  "technical/readme",
+  "blog/tech",
+  "blog/essay",
+  "blog/owned-media",
+  "business/proposal",
+  "business/report",
+  "business/email",
+  "business/press-release",
+  "business/meeting-notes",
+];
+
 export type GenreGuess = { readonly genre: string; readonly from: "front-matter" | "path" | "content" };
 
 /**
@@ -35,9 +49,24 @@ export const guessGenre = (path: string, source: string, front: string | undefin
   return undefined;
 };
 
-/** front matter の genre / type を拾う。失敗しても落とさない。 */
-export const frontMatterGenre = (source: string): string | undefined => {
-  const match = /^---\n([\s\S]*?)\n---/u.exec(source);
-  const line = match?.[1] === undefined ? undefined : /^(?:genre|type):\s*(\S+)\s*$/mu.exec(match[1]);
-  return line?.[1];
+/** YAML の 1 行の値。行末のコメントと、値を囲む引用符を外す。 */
+const scalarOf = (raw: string): string => {
+  const comment = raw.search(/\s#/u);
+  const value = (comment === -1 ? raw : raw.slice(0, comment)).trim();
+  return /^(["'])(.*)\1$/u.exec(value)?.[2] ?? value;
+};
+
+const valuesOf = (block: string, key: string): string[] => [...block.matchAll(new RegExp(`^${key}:(.*)$`, "gmu"))].map((line) => scalarOf(line[1] ?? ""));
+
+/** front matter の 1 つの欄に書かれた値。front matter が無ければ空。 */
+export const frontMatterValues = (source: string, key: string): string[] => {
+  const block = /^---\n([\s\S]*?)\n---/u.exec(source)?.[1];
+  return block === undefined ? [] : valuesOf(block, key);
 };
+
+/**
+ * front matter の genre / type を拾う。失敗しても落とさない。genre が type より先。
+ * 知っているジャンルだけを返す。Zenn の type（tech / idea）のような別の意味の値をジャンルにすると、どの rule も当てはまらず「指摘なし」になる。
+ */
+export const frontMatterGenre = (source: string): string | undefined =>
+  [...frontMatterValues(source, "genre"), ...frontMatterValues(source, "type")].find((value) => GENRES.includes(value));

package/src/init.ts

@@ -125,16 +125,3 @@ export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): stri
     "",
   ];
 };
-
-export const GENRES: readonly string[] = [
-  "technical/spec",
-  "technical/readme",
-  "blog/tech",
-  "blog/essay",
-  "blog/owned-media",
-  "business/proposal",
-  "business/report",
-  "business/email",
-  "business/press-release",
-  "business/meeting-notes",
-];

package/src/joined-view.ts

@@ -0,0 +1,96 @@
+import { spansWithin, withoutSpans } from "./soft-break.ts";
+import { continuedBreaks, wrapBreaks } from "./line-continues.ts";
+import type { Segmentation, Sentence, Span, Token } from "./plugin.ts";
+
+/**
+ * 消える改行を取り除いた文字列と、その上の範囲を元の文字列の範囲に戻す写像。
+ *
+ * 解析はつないだ文字列で行い、指摘の位置は元の文字列で出す。行・列も、引用して見せる範囲も、元の文書のまま。
+ */
+export type JoinedView = { readonly text: string; readonly toSource: (span: Span) => Span };
+
+type Removed = { readonly at: number; readonly removedBefore: number };
+
+/** 取り除いた各範囲が、つないだ文字列のどこにあったか。removedBefore はそこまでに取り除いた長さ（その範囲を含む）。 */
+const removedPlaces = (breaks: readonly Span[]): Removed[] => {
+  const places: Removed[] = [];
+  breaks.reduce((before, span) => {
+    const removedBefore = before + span.end - span.start;
+    places.push({ at: span.start - before, removedBefore });
+    return removedBefore;
+  }, 0);
+  return places;
+};
+
+/** at が offset 以下（inclusive）または未満の、最後の範囲までに取り除いた長さ。places は at の昇順。 */
+const removedUpTo = (places: readonly Removed[], offset: number, inclusive: boolean): number => {
+  const search = (low: number, high: number, found: number): number => {
+    if (low > high) return found;
+    const middle = (low + high) >> 1;
+    const place = places[middle];
+    if (place === undefined) return found;
+    const reached = inclusive ? place.at <= offset : place.at < offset;
+    return reached ? search(middle + 1, high, place.removedBefore) : search(low, middle - 1, found);
+  };
+  return search(0, places.length - 1, 0);
+};
+
+/**
+ * 始まりは、そこで取り除いた改行の後ろ（次の文字）へ。終わりは、そこで取り除いた改行の手前へ。
+ * 改行をまたぐ語（「関\nする」）は、改行ごと覆う範囲になる。
+ */
+export const joinedView = (text: string, breaks: readonly Span[]): JoinedView => {
+  const places = removedPlaces(breaks);
+  const toSource = (span: Span): Span => {
+    const start = span.start + removedUpTo(places, span.start, true);
+    const end = span.end + removedUpTo(places, span.end, false);
+    return { start, end: Math.max(start, end) };
+  };
+  return { text: withoutSpans(text, breaks), toSource };
+};
+
+const tokenInSource =
+  (view: JoinedView) =>
+  (token: Token): Token => ({ ...token, span: view.toSource(token.span) });
+
+const sentenceInSource =
+  (text: string, view: JoinedView) =>
+  (sentence: Sentence): Sentence => {
+    const span = view.toSource(sentence.span);
+    return {
+      span,
+      text: text.slice(span.start, span.end),
+      ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map(tokenInSource(view)) }),
+    };
+  };
+
+type Segment = (text: string) => Segmentation;
+
+/** breaks を除いて segment し、文と語の範囲を text の上に戻す。文の text は元の文字列の切り出しのまま。 */
+const segmentWithout = (text: string, breaks: readonly Span[], segment: Segment): Sentence[] => {
+  const view = joinedView(text, breaks);
+  return segment(view.text).sentences.map(sentenceInSource(text, view));
+};
+
+const withWrapBreaks = (sentence: Sentence, wrapped: readonly Span[]): Sentence => {
+  const inside = spansWithin(wrapped, sentence.span);
+  return inside.length === 0 ? sentence : { ...sentence, wrapBreaks: inside };
+};
+
+const tokensOf = (sentences: readonly Sentence[]): Token[] => sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/**
+ * 消える改行を、行が続いていると言えるものだけ除いて segment する。
+ * 一度すべて除いて解析し、その語で決めて、残す改行があれば読み直す。
+ * 語が無ければ（品詞を読まない adapter）決められないので、前と同じく改行ごと渡す。
+ * 除く改行が無ければ segment の結果をそのまま返す。つながない段落の文は、前と同じものになる。
+ */
+export const segmentJoined = (text: string, breaks: readonly Span[], segment: Segment): readonly Sentence[] => {
+  if (breaks.length === 0) return segment(text).sentences;
+  const joined = segmentWithout(text, breaks, segment);
+  const kept = continuedBreaks(breaks, tokensOf(joined));
+  if (kept.length === 0) return segment(text).sentences;
+  const sentences = kept.length === breaks.length ? joined : segmentWithout(text, kept, segment);
+  const wrapped = wrapBreaks(kept, tokensOf(sentences));
+  return sentences.map((sentence) => withWrapBreaks(sentence, wrapped));
+};

package/src/line-continues.ts

@@ -0,0 +1,43 @@
+import { firstEndingAfter } from "./soft-break.ts";
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 消える改行のうち、どれを消して読むか。決めるのは解析器が読んだ語（全部の改行を消して読んだもの）。
+ *
+ * Markdown の段落は改行を消して表示されるが、書いた人は改行で区切ったつもりのことがある。
+ * 番号だけの見出しの行（「2.1 注文の登録\n登録は」）、宛先や署名を 1 行に 1 つ書いた並び。
+ * そこを消して読むと「登録登録」が語の重なりになる。行が続いていると語で言えるときだけ消す。
+ */
+
+const inside = (token: Token | undefined, part: Span): boolean => token !== undefined && token.span.start < part.start && token.span.end > part.end;
+
+type Around = { readonly across: Token | undefined; readonly before: Token | undefined };
+
+/** 各改行の位置で、改行をまたぐ語（あれば）と、改行の直前で終わる語。tokens は並び順（重ならない）。 */
+const aroundEach = (breaks: readonly Span[], tokens: readonly Token[]): Around[] => {
+  const spans = tokens.map((token) => token.span);
+  return breaks.map((part) => {
+    const at = firstEndingAfter(spans, part.start);
+    return { across: tokens[at], before: tokens[at - 1] };
+  });
+};
+
+/** 解析器が語の途中に置いた改行。語をまたぐなら、行を折り返しただけ。 */
+export const wrapBreaks = (breaks: readonly Span[], tokens: readonly Token[]): Span[] => {
+  const around = aroundEach(breaks, tokens);
+  return breaks.filter((part, index) => inside(around[index]?.across, part));
+};
+
+/** 句を閉じない語。助詞・接続助詞・接続詞で終わる行は、次の行へ続く。 */
+const CONTINUING_POS = new Set(["ADP", "SCONJ", "CCONJ"]);
+/** 読点で終わる行も続く。句点・括弧・名詞で終わる行は、見出しや 1 行 1 項目の終わりと見分けられない。 */
+const COMMAS = new Set(["、", "，"]);
+
+const continuesPast = (token: Token | undefined, part: Span): boolean =>
+  token !== undefined && token.span.end === part.start && (CONTINUING_POS.has(token.pos) || COMMAS.has(token.surface));
+
+/** 行が続いている改行: 語をまたぐものと、句を閉じない語の直後にあるもの。 */
+export const continuedBreaks = (breaks: readonly Span[], tokens: readonly Token[]): Span[] => {
+  const around = aroundEach(breaks, tokens);
+  return breaks.filter((part, index) => inside(around[index]?.across, part) || continuesPast(around[index]?.before, part));
+};

package/src/measure.ts

@@ -1,3 +1,4 @@
+import { withoutSpans } from "./soft-break.ts";
 import type { Sentence } from "./plugin.ts";
 
 /**
@@ -9,7 +10,14 @@ import type { Sentence } from "./plugin.ts";
  *
  * 日本語は文字数、英語は語数。単位は adapter が宣言する。
  */
-export const proseText = (sentence: Sentence): string => sentence.text.replace(/\s+/gu, " ").trim();
+/** 語の途中で折り返した改行（wrapBreaks）は空白にせず除く。「関\nする」を「関 する」と読まない。 */
+export const proseText = (sentence: Sentence): string =>
+  withoutSpans(
+    sentence.text,
+    (sentence.wrapBreaks ?? []).map((span) => ({ start: span.start - sentence.span.start, end: span.end - sentence.span.start })),
+  )
+    .replace(/\s+/gu, " ")
+    .trim();
 
 export const charLength = (sentence: Sentence): number => sentence.text.replace(/\s+/gu, "").length;