chaffjs 0.14.0 → 0.15.0

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;
 

package/src/number-name.ts

@@ -1,12 +1,13 @@
+import { hyphenGroups, isHyphen } from "./orthography.ts";
 import type { Span, Token } from "./plugin.ts";
 
 /**
  * 数量ではなく名前として書かれた数（番号・識別子）。鉤括弧で引いた「3.1 リサーチの原則」の節番号、※1 のような注の番号、
- * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
+ * 「〒100-8916 東京都」の郵便番号、「紀尾井町1-3 東京ガーデンテラス」の番地は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
  * 空け方を数える材料にしない。
  *
- * 形で名前と読むのは四つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）、
- * 続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * 形で名前と読むのは五つだけ。0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
+ * 文頭の階層つきの節番号（2.1、3.1.2）、続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
  * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
  * 品詞が無ければ判断せず、名前とは読まない。
  */
@@ -14,8 +15,8 @@ import type { Span, Token } from "./plugin.ts";
 /** 数と結びついて読まれる語。助数詞は NounType=Class、数は NumType=Card で渡る。 */
 const BOUND_TO_NUMBER = new Set(["ADP", "PART", "AUX", "SCONJ", "CCONJ"]);
 
-/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印。 */
-const LABEL_LEAD = /[「『【※]$/u;
+/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印、郵便番号の印。 */
+const LABEL_LEAD = /[「『【※〒]$/u;
 
 /** 文頭（前に空白と箇条書きの印だけ）。 */
 const LINE_HEAD = /^[\s\-*+・•]*$/u;
@@ -28,17 +29,18 @@ const SECTION_NUMBER = /^\d+(?:\.\d+)+$/u;
  * 数え続ける。三つ以上つないだもの（073-489-5909）は、orthography.ts が境目を作る前に外している。
  */
 const isHyphenIdentifier = (digits: string): boolean => {
-  const parts = digits.split("-").filter((part) => part !== "");
+  const parts = hyphenGroups(digits);
   return parts.length > 1 && parts.some((part) => part.startsWith("0"));
 };
 
-const RUN_CHAR = /[\d.-]/u;
+const DIGIT_OR_POINT = /[\d.]/u;
+const isRunChar = (char: string | undefined): boolean => DIGIT_OR_POINT.test(char ?? "") || isHyphen(char);
 
-/** at を含む、数字・小数点・ハイフンの並び。at が並びの中に無ければ undefined。 */
+/** at を含む、数字・小数点・ハイフン（全角の「－」なども）の並び。at が並びの中に無ければ undefined。 */
 export const digitRunAround = (text: string, at: number): Span | undefined => {
-  if (!RUN_CHAR.test(text[at] ?? "")) return undefined;
-  const startAt = (index: number): number => (index > 0 && RUN_CHAR.test(text[index - 1] ?? "") ? startAt(index - 1) : index);
-  const endAt = (index: number): number => (index < text.length && RUN_CHAR.test(text[index] ?? "") ? endAt(index + 1) : index);
+  if (!isRunChar(text[at])) return undefined;
+  const startAt = (index: number): number => (index > 0 && isRunChar(text[index - 1]) ? startAt(index - 1) : index);
+  const endAt = (index: number): number => (index < text.length && isRunChar(text[index]) ? endAt(index + 1) : index);
   return { start: startAt(at), end: endAt(at) };
 };
 
@@ -71,6 +73,24 @@ export const sequenceLabelStarts = (text: string): ReadonlySet<number> => {
   return new Set(lines.flatMap((line, index) => (continues(index) ? [line.start] : [])));
 };
 
+const isGeoUnit = (token: Token): boolean => token.features?.["NameType"] === "GeoUnit";
+const isPlaceWord = (token: Token): boolean => isGeoUnit(token) || token.features?.["NameType"] === "Geo";
+
+/** end で終わる、間を空けずに続く地名と地名の単位（東京都千代田区紀尾井町）。近いほうから。 */
+export const placeChainBefore = (tokens: readonly Token[], end: number): Token[] => {
+  const last = tokens.find((token) => token.span.end === end && isPlaceWord(token));
+  return last === undefined ? [] : [last, ...placeChainBefore(tokens, last.span.start)];
+};
+
+/**
+ * 住所の番地（千代田区紀尾井町1-3、霞が関2-1）。都道府県より下の単位（市・区・町）まで下りた地名のすぐ後ろの、ハイフンつなぎの番号。
+ * 地名だけ（北海道2-3 営業日）や都道府県まで（東京都2-3 営業日）の後ろは、地域ごとの範囲のことがあるので読まない。
+ * ハイフンの無い数（千代田区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) &&
+  placeChainBefore(tokens, base + run.start).some((token) => isGeoUnit(token) && !topUnits.has(token.surface));
+
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
 const isNameShaped = (text: string, run: Span): boolean => {
   const [before, digits] = [text.slice(0, run.start), text.slice(run.start, run.end)];
@@ -78,7 +98,8 @@ const isNameShaped = (text: string, run: Span): boolean => {
 };
 
 /**
- * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果。
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果、
+ * topUnits は都道府県の単位。
  * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
  */
 export const isNumberName = (
@@ -87,9 +108,10 @@ export const isNumberName = (
   tokens: readonly Token[] | undefined,
   base: number,
   sequence: ReadonlySet<number> = new Set(),
+  topUnits: ReadonlySet<string> = new Set(),
 ): boolean => {
   const inSequence = sequence.has(base + run.start);
-  if (tokens === undefined || !(inSequence || isNameShaped(text, run))) return false;
+  if (tokens === undefined || !(inSequence || isNameShaped(text, run) || isAddressNumber(text, run, tokens, base, topUnits))) return false;
   const next = wordAfter(tokens, text, run, base);
   if (next === undefined) return false;
   return !isBoundToNumber(next) || (inSequence && CONJUNCTIONS.has(next.pos));

package/src/orthography.ts

@@ -125,22 +125,28 @@ const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
 };
 
 /**
- * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」のように - でつないだ 3 組以上の数字は、電話番号・日付・図の番号で
+ * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」「5－1－1」のように - でつないだ 3 組以上の数字は、電話番号・日付・図や項目の番号で
  * 数量ではない。後ろの空白は欄の区切りで、「3回」の空け方とは別のもの。両側とも数えない。
  * 2 組（「1-3ヶ月」「20-30分」）は幅のある数量なので数える。
  */
 const MIN_CODE_GROUPS = 3;
-const CODE_CHAR = /[\d-]/u;
+
+// 通達の「5－1－1」は全角の「－」でつなぐ。ハイフン「‐」やマイナス「−」も同じに読む。長音「ー」は仮名の一部なので入れない。
+const HYPHEN = /[-‐‑−－]/u;
+
+/** 数字をつなぐハイフンか。半角の - のほか、全角・和文のハイフンも。 */
+export const isHyphen = (char: string | undefined): boolean => char !== undefined && HYPHEN.test(char);
+
+/** ハイフンで区切った組（空の組は除く）。「5－1－1」は ["5", "1", "1"]。 */
+export const hyphenGroups = (text: string): string[] => text.split(HYPHEN).filter((group) => group !== "");
+
+const isCodeChar = (char: string | undefined): boolean => DIGIT.test(char ?? "") || isHyphen(char);
 
 const isCode = (chars: readonly string[], digit: number): boolean => {
   let [first, last] = [digit, digit];
-  while (first > 0 && CODE_CHAR.test(chars[first - 1] ?? "")) first -= 1;
-  while (last < chars.length - 1 && CODE_CHAR.test(chars[last + 1] ?? "")) last += 1;
-  const groups = chars
-    .slice(first, last + 1)
-    .join("")
-    .split("-");
-  return groups.filter((group) => group !== "").length >= MIN_CODE_GROUPS;
+  while (first > 0 && isCodeChar(chars[first - 1])) first -= 1;
+  while (last < chars.length - 1 && isCodeChar(chars[last + 1])) last += 1;
+  return hyphenGroups(chars.slice(first, last + 1).join("")).length >= MIN_CODE_GROUPS;
 };
 
 /** 日本語との境目にある数字が、数えない書き方（「第3条」の番地、「073-489-5909」の符号）か。 */

package/src/plain-source.ts

@@ -0,0 +1,5 @@
+/**
+ * The Markdown parser drops a leading BOM and reads a lone "\r" as a line break; the rest of chaff counts "\n" only.
+ * Reading the file this way keeps every offset, line and column on the text the writer sees.
+ */
+export const plainSource = (raw: string): string => raw.replace(/^\uFEFF/u, "").replace(/\r\n?/gu, "\n");

package/src/plugin.ts

@@ -8,7 +8,16 @@ export type Span = { readonly start: number; readonly end: number };
  * token の span は文の span と同じ座標系（segment に渡した文字列の先頭が 0）。
  * 2 つの基準を混ぜると、ずれたときに どちらが悪いか分からなくなる。
  */
-export type Sentence = { readonly span: Span; readonly text: string; readonly tokens?: readonly Token[] };
+export type Sentence = {
+  readonly span: Span;
+  readonly text: string;
+  readonly tokens?: readonly Token[];
+  /**
+   * 行の折り返しで語の途中に入った改行（前後の行頭・行末の空白ごと）。span と同じ座標系。chaff が入れる。
+   * tokens は全角どうしに挟まれた段落内の改行を除いた文字列から作るので、改行をまたぐ語の span は改行ごと覆い、surface より長い。
+   */
+  readonly wrapBreaks?: readonly Span[];
+};
 
 /**
  * 品詞は Universal Dependencies の UPOS に統一する。アダプタ独自の体系を露出させない。
@@ -133,7 +142,10 @@ export type StructurePatterns = {
   readonly numbered: (line: string, context: NumberingContext) => NumberedLine | undefined;
   /** 定義。attrs.term に定義された語。 */
   readonly definitions: (text: string) => readonly Mention[];
-  /** 参照。attrs.target に正規化した番地（"12.1"）、attrs.label に書かれたまま。 */
+  /**
+   * 参照。attrs.target に正規化した番地（"12.1"）、attrs.label に書かれたまま。他の文書を指すなら attrs.document にその名。
+   * 書き方だけでは他の文書か決まらない角括弧の語は attrs.citedTag に入れ、文書がその語を一覧に載せていれば core が他の文書とみなす。
+   */
   readonly references: (text: string) => readonly Mention[];
   /** 義務・禁止・許可。attrs.marker に語、attrs.type に must / must-not / may。 */
   readonly obligations: (text: string) => readonly Mention[];
@@ -156,6 +168,11 @@ export type StructurePatterns = {
    * 数字と点だけの通し番号は core が言語を問わず読むので、それを数量と見分けられるのは言語パッケージだけ。
    */
   readonly countedAfter?: (number: string, rest: string) => boolean;
+  /**
+   * 本文の行頭の「3.11.0 を公開しました。」の 3.11.0 は、文の中の数で通し番号ではない。番号と後ろの文字列を渡し、文の続き
+   * （日本語なら助詞で始まる）なら true。小文字で始まる続きは core が言語を問わず読む。
+   */
+  readonly continuesSentence?: (number: string, rest: string) => boolean;
   /** 数の書き方（「二十二」「3」）を数にする。相対の参照の「前二項」「前条第二項」が使う。 */
   readonly number?: (text: string) => number | undefined;
 };
@@ -291,6 +308,8 @@ export type ProseDocument = {
   readonly paragraphs: readonly Paragraph[];
   /** 箇条書き 1 つ。項目の数と長さのばらつきを見る rule が使う。 */
   readonly lists: readonly BulletList[];
+  /** リンク（`[text](url)`、`<https://…>`、`[text][ref]`）の範囲。行き先が相対パスでもページ内でも、読み手が辿れる出典。 */
+  readonly links: readonly Span[];
   /** アダプタが持つ語彙表と、チームが chaff.yaml に足した語彙表。detector は出所を知らない。 */
   readonly lexicons: Readonly<Record<string, Lexicon>>;
   /** この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。 */

package/src/quoted-span.ts

@@ -0,0 +1,25 @@
+import type { Span } from "./plugin.ts";
+
+/** 鉤括弧の開きと、それを閉じる字。 */
+const CLOSER: Readonly<Record<string, string>> = { "「": "」", "『": "』" };
+
+type Open = { readonly closer: string; readonly at: number };
+type Scan = { readonly open: readonly Open[]; readonly spans: readonly Span[] };
+
+const step = (scan: Scan, char: string, at: number): Scan => {
+  const closer = CLOSER[char];
+  if (closer !== undefined) return { open: [...scan.open, { closer, at }], spans: scan.spans };
+  const last = scan.open.at(-1);
+  if (last === undefined || last.closer !== char) return scan;
+  return { open: scan.open.slice(0, -1), spans: [...scan.spans, { start: last.at + 1, end: at }] };
+};
+
+/**
+ * 鉤括弧（「」『』）の中身の位置。括弧そのものは含まない。入れ子はそれぞれを返す。
+ * 閉じない括弧と、開きと組にならない閉じ括弧は中身を作らない。位置は text の先頭を 0 とする。
+ * 括弧は BMP の字なので、UTF-16 の 1 単位ずつ見れば位置がそのまま使える。
+ */
+export const quotedSpans = (text: string): Span[] => [...text.split("").reduce<Scan>((scan, char, at) => step(scan, char, at), { open: [], spans: [] }).spans];
+
+/** inner が、spans のどれかにまるごと入っているか。 */
+export const isWithinAny = (spans: readonly Span[], inner: Span): boolean => spans.some((span) => inner.start >= span.start && inner.end <= span.end);

package/src/render/eval.ts

@@ -1,62 +1,125 @@
-import { MIN_CORPUS, TARGET_HIT_RATE, type RuleReport } from "../eval.ts";
+import { MIN_CORPUS, TARGET_HIT_RATE, type Point, type RuleReport } from "../eval.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
 
 const pct = (part: number, whole: number): string => `${((part / Math.max(1, whole)) * 100).toFixed(1)}%`;
 
-const mark = (report: RuleReport, limit: number): string => {
-  if (limit === report.current && limit === report.recommended) return "  ← 現在 / 推奨";
-  if (limit === report.current) return "  ← 現在";
-  if (limit === report.recommended) return "  ← 推奨";
+const TARGET = TARGET_HIT_RATE * 100;
+
+/** In the English hint, a rule's line sits one YAML level under `rules:`. */
+const EN_CONFIG_LEAD = "    In chaff.yaml:  ";
+const YAML_INDENT = 2;
+
+const TEXT: Texts<{
+  readonly current: string;
+  readonly recommended: string;
+  readonly both: string;
+  readonly point: (point: Point, share: string) => string;
+  readonly fits: string;
+  readonly nothingFits: string;
+  readonly over: (share: string) => string;
+  readonly recommend: (limit: number) => string;
+  readonly toConfig: (rule: string, limit: number) => string;
+  readonly measured: (paths: number, rules: number) => string;
+  readonly premise: readonly string[];
+  readonly smallCorpus: (total: number) => readonly string[];
+  readonly untouched: string;
+}> = {
+  ja: {
+    current: "  ← 現在",
+    recommended: "  ← 推奨",
+    both: "  ← 現在 / 推奨",
+    point: (point, share) =>
+      `${String(point.documents).padStart(3)} 文書 (${share.padStart(6)})   指摘 ${String(point.findings).padStart(3)} 件   1万字あたり ${point.per10k.toFixed(1)}`,
+    fits: `    いまの閾値で目標（${TARGET}% 未満）を満たしています。`,
+    nothingFits: `    どの閾値でも目標を満たしません。この corpus に対して rule 自体が合っていない可能性があります。`,
+    over: (share) => `    いまの閾値では ${share} の文書が該当し、目標（${TARGET}% 未満）を超えています。`,
+    recommend: (limit) => `    推奨: ${limit}`,
+    toConfig: (rule, limit) => `    chaff.yaml に書くなら:  rules:\n                              ${rule}: ${limit}`,
+    measured: (paths, rules) => `  ${paths} ファイルを corpus として ${rules} 本の rule を測りました。`,
+    premise: [
+      "  ここにある文書は「人間が書いて公開した良い文書」として扱っています。",
+      `  そこで多く発火する rule は、閾値が現実に合っていない疑いがあります（目標: ${TARGET}% 未満）。`,
+    ],
+    smallCorpus: (total) => [
+      `  ※ corpus が ${total} 文書しかありません。${TARGET}% を表すには ${MIN_CORPUS} 文書以上が要ります。`,
+      "     いまは割合が「0 か全部」に振れるので、右端の密度（1万字あたりの指摘数）のほうを見てください。",
+    ],
+    untouched: `  閾値は自動で書き換えていません。corpus が変われば答えも変わるためです。`,
+  },
+  en: {
+    current: "  ← current",
+    recommended: "  ← recommended",
+    both: "  ← current / recommended",
+    point: (point, share) =>
+      `${String(point.documents).padStart(3)} ${point.documents === 1 ? "doc " : "docs"} (${share.padStart(6)})   ${String(point.findings).padStart(3)} ${point.findings === 1 ? "finding " : "findings"}   ${point.per10k.toFixed(1)} per 10,000 characters`,
+    fits: `    The current limit meets the target (under ${TARGET}%).`,
+    nothingFits: "    No limit meets the target. The rule itself may not suit this corpus.",
+    over: (share) => `    At the current limit ${share} of the documents are hit, over the target (under ${TARGET}%).`,
+    recommend: (limit) => `    Recommended: ${limit}`,
+    toConfig: (rule, limit) => `${EN_CONFIG_LEAD}rules:\n${" ".repeat(EN_CONFIG_LEAD.length + YAML_INDENT)}${rule}: ${limit}`,
+    measured: (paths, rules) => `  Measured ${rules} rule${rules === 1 ? "" : "s"} on ${paths} file${paths === 1 ? "" : "s"} as a corpus.`,
+    premise: [
+      "  The documents here are taken as good documents that people wrote and published.",
+      `  A rule that fires often on them may have a limit that does not fit real writing (target: under ${TARGET}%).`,
+    ],
+    smallCorpus: (total) => [
+      `  Note: the corpus has only ${total} document${total === 1 ? "" : "s"}. Showing ${TARGET}% takes at least ${MIN_CORPUS}.`,
+      "     For now each share is either 0 or all, so read the density on the right (findings per 10,000 characters).",
+    ],
+    untouched: "  No limit was changed. A different corpus gives a different answer.",
+  },
+};
+
+type EvalText = (typeof TEXT)[UiLanguage];
+
+const mark = (report: RuleReport, limit: number, text: EvalText): string => {
+  if (limit === report.current && limit === report.recommended) return text.both;
+  if (limit === report.current) return text.current;
+  if (limit === report.recommended) return text.recommended;
   return "";
 };
 
-const sweepLines = (report: RuleReport): string[] =>
-  report.sweep.map((point) => {
-    const limit = String(point.limit).padStart(6);
-    const docs = `${String(point.documents).padStart(3)} 文書`;
-    const density = `1万字あたり ${point.per10k.toFixed(1)}`;
-    return `    ${limit}   ${docs} (${pct(point.documents, report.total).padStart(6)})   指摘 ${String(point.findings).padStart(3)} 件   ${density}${mark(report, point.limit)}`;
-  });
+const sweepLines = (report: RuleReport, text: EvalText): string[] =>
+  report.sweep.map(
+    (point) => `    ${String(point.limit).padStart(6)}   ${text.point(point, pct(point.documents, report.total))}${mark(report, point.limit, text)}`,
+  );
 
-const verdict = (report: RuleReport): string[] => {
+const verdict = (report: RuleReport, text: EvalText): string[] => {
   const now = report.sweep.find((point) => point.limit === report.current);
   const rate = now === undefined ? 0 : now.documents / Math.max(1, report.total);
-  if (rate <= TARGET_HIT_RATE) return [`    いまの閾値で目標（${TARGET_HIT_RATE * 100}% 未満）を満たしています。`];
-  if (report.recommended === undefined) {
-    return [`    どの閾値でも目標を満たしません。この corpus に対して rule 自体が合っていない可能性があります。`];
-  }
-  return [
-    `    いまの閾値では ${pct(now?.documents ?? 0, report.total)} の文書が該当し、目標（${TARGET_HIT_RATE * 100}% 未満）を超えています。`,
-    `    推奨: ${report.recommended}`,
-    "",
-    `    chaff.yaml に書くなら:  rules:\n                              ${report.rule}: ${report.recommended}`,
-  ];
+  if (rate <= TARGET_HIT_RATE) return [text.fits];
+  if (report.recommended === undefined) return [text.nothingFits];
+  return [text.over(pct(now?.documents ?? 0, report.total)), text.recommend(report.recommended), "", text.toConfig(report.rule, report.recommended)];
 };
 
-const block = (report: RuleReport): string[] => ["", `  ${report.name}   (${report.rule})`, "", ...sweepLines(report), "", ...verdict(report), ""];
+const block = (report: RuleReport, text: EvalText): string[] => [
+  "",
+  `  ${report.name}   (${report.rule})`,
+  "",
+  ...sweepLines(report, text),
+  "",
+  ...verdict(report, text),
+  "",
+];
 
 /**
  * 閾値は自動で書き換えない。提示して選ばせる。
  * 較正は corpus に対する答えであって、正解ではないため。
  */
-export const renderEval = (reports: readonly RuleReport[], total: number, paths: number): string =>
-  [
+export const renderEval = (reports: readonly RuleReport[], total: number, paths: number, ui: UiLanguage): string => {
+  const text = TEXT[ui];
+  return [
     "",
-    `  ${paths} ファイルを corpus として ${reports.length} 本の rule を測りました。`,
+    text.measured(paths, reports.length),
     "",
-    "  ここにある文書は「人間が書いて公開した良い文書」として扱っています。",
-    `  そこで多く発火する rule は、閾値が現実に合っていない疑いがあります（目標: ${TARGET_HIT_RATE * 100}% 未満）。`,
-    ...(total < MIN_CORPUS
-      ? [
-          "",
-          `  ※ corpus が ${total} 文書しかありません。${TARGET_HIT_RATE * 100}% を表すには ${MIN_CORPUS} 文書以上が要ります。`,
-          "     いまは割合が「0 か全部」に振れるので、右端の密度（1万字あたりの指摘数）のほうを見てください。",
-        ]
-      : []),
-    ...reports.flatMap(block),
+    ...text.premise,
+    ...(total < MIN_CORPUS ? ["", ...text.smallCorpus(total)] : []),
+    ...reports.flatMap((report) => block(report, text)),
     "  " + "─".repeat(58),
     "",
-    `  閾値は自動で書き換えていません。corpus が変われば答えも変わるためです。`,
+    text.untouched,
     "",
   ]
     .join("\n")
     .replace(/\{total\}/gu, String(total));
+};

package/src/resolve-genre.ts

@@ -0,0 +1,20 @@
+import { applyByPath } from "./config/by-path.ts";
+import type { Config } from "./config/load.ts";
+import type { GenreSource } from "./cli-text.ts";
+import { frontMatterGenre, GENRES, guessGenre } from "./genre.ts";
+import { unknownFrontMatterGenre } from "./genre-check.ts";
+
+/** unread: a genre the front matter wrote that chaff does not know, when the front matter was looked at. */
+type ResolvedGenre = { readonly genre: string; readonly from: GenreSource; readonly unread?: string | undefined };
+
+export const resolveGenre = (path: string, source: string, config: Config, cliGenre?: string): ResolvedGenre => {
+  // コマンドで指定したものが最優先。その実行だけの指定だから、設定より強い。
+  if (cliGenre !== undefined) return { genre: cliGenre, from: "--genre" };
+  // パスごとの上書きが次。「全体はこう、ここだけは違う」を書けるようにする。
+  const override = applyByPath(config.byPath, config.baseDir, path);
+  if (override.genre !== undefined) return { genre: override.genre, from: "by_path" };
+  if (config.genre !== undefined) return { genre: config.genre, from: "config" };
+  const guess = guessGenre(path, source, frontMatterGenre(source));
+  const unread = unknownFrontMatterGenre(source, GENRES);
+  return guess === undefined ? { genre: "blog/tech", from: "default", unread } : { genre: guess.genre, from: guess.from, unread };
+};