chaffjs 0.15.0 → 0.17.0

package/src/sentence-shape.ts

@@ -11,10 +11,6 @@ const ENDS = /[。．.！？!?][")）」』\s]*$/u;
 
 export const isClosed = (sentence: Sentence): boolean => ENDS.test(sentence.text);
 
-const PREDICATE = new Set(["AUX", "VERB", "ADJ"]);
-
-export const hasPredicate = (sentence: Sentence): boolean => (sentence.tokens ?? []).some((token) => PREDICATE.has(token.pos));
-
 export const hasParticle = (sentence: Sentence): boolean => (sentence.tokens ?? []).some((token) => token.pos === "ADP" || token.pos === "SCONJ");
 
 const SKIP = new Set(["PUNCT", "PART", "SYM"]);
@@ -46,11 +42,11 @@ const CLOSING_QUOTES = ["」", "』", "\u201d"];
  * 引用で終わる文（画面には「確認します。」。）は、書き手の文末が無いので空。
  */
 export const endingTokens = (sentence: Sentence): Token[] => {
-  const reversed = [...beforeTrailing(sentence)].reverse();
+  const reversed = beforeTrailing(sentence).toReversed();
   const last = reversed.findIndex((token) => !SKIP.has(token.pos));
   if (last === -1 || reversed.slice(0, last).some((token) => CLOSING_QUOTES.some((quote) => token.surface.includes(quote)))) return [];
   const head = reversed.findIndex((token, index) => index >= last && token.pos !== "AUX");
-  return reversed.slice(last, head === -1 ? reversed.length : head + 1).reverse();
+  return reversed.slice(last, head === -1 ? reversed.length : head + 1).toReversed();
 };
 
-export const lastContent = (sentence: Sentence): Token | undefined => [...beforeTrailing(sentence)].reverse().find((token) => !SKIP.has(token.pos));
+export const lastContent = (sentence: Sentence): Token | undefined => beforeTrailing(sentence).findLast((token) => !SKIP.has(token.pos));

package/src/setting-problems.ts

@@ -0,0 +1,24 @@
+import type { Config } from "./config/load.ts";
+import type { CliText } from "./cli-text.ts";
+import { GENRES } from "./genre.ts";
+import { unknownGenres, writtenGenres } from "./genre-check.ts";
+import { loadProfiles } from "./profile/load.ts";
+import { unknownProfiles, writtenProfiles } from "./profile/check.ts";
+
+const genreProblems = (command: string, genreFlag: string | undefined, config: Config, text: CliText): string[] =>
+  unknownGenres(writtenGenres(command, genreFlag, config), GENRES).map((entry) =>
+    text.unknownGenre(entry.genre, text.genreWhere(entry.where, entry.files), GENRES),
+  );
+
+const profileProblems = (command: string, config: Config, text: CliText): string[] => {
+  const known = loadProfiles().map((definition) => definition.id);
+  return unknownProfiles(writtenProfiles(command, config), known).map((entry) =>
+    text.unknownProfile(entry.profile, text.profileWhere(entry.where, entry.files), known),
+  );
+};
+
+/** 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[] => [
+  ...genreProblems(command, genreFlag, config, text),
+  ...profileProblems(command, config, text),
+];

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/build.ts

@@ -73,9 +73,9 @@ const open = (state: State, frame: Frame): void => {
   state.stack.push(frame);
 };
 
-const nearestNumbered = (state: State): Frame | undefined => [...state.stack].reverse().find((frame) => frame.numbered !== undefined);
+const nearestNumbered = (state: State): Frame | undefined => state.stack.findLast((frame) => frame.numbered !== undefined);
 
-const nearestSection = (state: State): Frame | undefined => [...state.stack].reverse().find((frame) => frame.draft.kind === "section");
+const nearestSection = (state: State): Frame | undefined => state.stack.findLast((frame) => frame.draft.kind === "section");
 
 /**
  * 条番号や 4.2 はそれだけで番地になる。項・号・(a) は親の番地に続ける。親が無ければ節の中の番号とする。
@@ -160,12 +160,12 @@ const universalNumber = (patterns: StructurePatterns, text: string, context: Num
 };
 
 /** 行の中の定義・参照・義務・数量を、いま開いている最も内側の節点の子にする。 */
-const enclosingArticle = (state: State): Draft | undefined => [...state.stack].reverse().find((frame) => frame.draft.kind === "article")?.draft;
+const enclosingArticle = (state: State): Draft | undefined => state.stack.findLast((frame) => frame.draft.kind === "article")?.draft;
 
 /** 条より広い範囲（「In this Part」）なら、その深さの開いているまとまり。開いていなければ（Part の見出しの無い文書）無い。 */
 const widerScope = (state: State, patterns: StructurePatterns, text: string): Draft | undefined => {
   const depth = patterns.definitionScopeDepth?.(text);
-  return depth === undefined ? undefined : [...state.stack].reverse().find((frame) => frame.numbered?.depth === depth)?.draft;
+  return depth === undefined ? undefined : state.stack.findLast((frame) => frame.numbered?.depth === depth)?.draft;
 };
 
 /** 範囲を宣言した行を持つまとまり。条の中なら条、条の外（Markdown の見出しの下、Part の直下）なら開いている一番内側のもの。 */
@@ -200,7 +200,7 @@ const addLeaves = (state: State, patterns: StructurePatterns, line: Line, wrappe
         attrs: mention.attrs,
       })),
     )
-    .sort((left, right) => left.start - right.start);
+    .toSorted((left, right) => left.start - right.start);
   leaves.forEach((leaf) =>
     parent.children.push({
       kind: leaf.kind,

package/src/structure/cite.ts

@@ -73,7 +73,7 @@ const addressedNodes = (tree: StructureNode): Addressed[] => {
     const current = pending.pop();
     if (current === undefined) break;
     if (current.node.address !== "") found.push(current);
-    [...current.node.children].reverse().forEach((child) => pending.push({ node: child, depth: current.depth + 1 }));
+    current.node.children.toReversed().forEach((child) => pending.push({ node: child, depth: current.depth + 1 }));
   }
   return found;
 };

package/src/structure/issues.ts

@@ -7,7 +7,7 @@ import { namesAbsentUnit } from "./unit-word.ts";
 
 export type StructureIssue = { readonly offset: number; readonly values: Readonly<Record<string, string | number>> };
 
-const NUMBERED: readonly string[] = ["chapter", "article", "item"];
+const NUMBERED: ReadonlySet<string> = new Set(["chapter", "article", "item"]);
 
 /** 木を上から順に平らにする。文書の中での順番と同じになる。再帰にしないのは、深い木でスタックを使い切らないため。 */
 export const inDocumentOrder = (tree: StructureNode): StructureNode[] => {
@@ -17,7 +17,7 @@ export const inDocumentOrder = (tree: StructureNode): StructureNode[] => {
     const node = pending.pop();
     if (node === undefined) break;
     order.push(node);
-    pending.push(...[...node.children].reverse());
+    pending.push(...node.children.toReversed());
   }
   return order;
 };
@@ -57,6 +57,8 @@ const citesOtherDocument =
   (node: StructureNode): boolean =>
     node.attrs["document"] !== undefined || (node.attrs["citedTag"] !== undefined && listed.has(textOf(node, "citedTag")));
 
+const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
+
 /**
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
  * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
@@ -67,10 +69,9 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   if (!nodes.some((node) => node.kind === "article")) return [];
   const tagged = nodes.some((node) => node.attrs["citedTag"] !== undefined);
   const citesOther = citesOtherDocument(tagged ? listedTags(source) : new Set());
-  const addresses = new Set(nodes.filter((node) => NUMBERED.includes(node.kind)).flatMap(keysOf));
+  const addresses = new Set(nodes.filter((node) => NUMBERED.has(node.kind)).flatMap(keysOf));
   // Section で組んだ法令が "Articles 13 to 21 of the UK GDPR" と別の文書の Article を名指ししていれば、名の無い "Article 6(3)" もそちら。
   // 名指しがあれば、名の無い "Article 9" が書き間違いか向こうの条かは区別できないので黙る。名指しが無い文書では報告する。
-  const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
   const numberings = new Set(nodes.flatMap((node) => (node.kind === "article" && node.numbering !== undefined ? [node.numbering] : [])));
   const citedElsewhere = new Set(nodes.filter((node) => node.kind === "reference" && citesOther(node)).map(numbering));
   const otherNumbering = (node: StructureNode): boolean =>
@@ -94,7 +95,7 @@ const definitionsInOrder = (tree: StructureNode): Definition[] => {
     if (current === undefined) break;
     if (current.node.kind === "definition") found.push(current);
     const article = current.node.kind === "article" ? current.node.address : current.article;
-    [...current.node.children].reverse().forEach((child) => pending.push({ node: child, article }));
+    current.node.children.toReversed().forEach((child) => pending.push({ node: child, article }));
   }
   return found;
 };

package/src/structure/markdown-path.ts

@@ -1,6 +1,6 @@
 import { extname } from "node:path";
 
-const MARKDOWN = [".md", ".markdown", ".mdx"];
+const MARKDOWN: ReadonlySet<string> = new Set([".md", ".markdown", ".mdx"]);
 
 /** 見出しとコードの範囲を Markdown として読むか。.txt の契約書は行頭の番号だけで木にする。 */
-export const isMarkdownPath = (path: string): boolean => MARKDOWN.includes(extname(path).toLowerCase());
+export const isMarkdownPath = (path: string): boolean => MARKDOWN.has(extname(path).toLowerCase());

package/src/structure/numbering.ts

@@ -46,4 +46,4 @@ export const numberingBreaks = (tree: StructureNode): StructureIssue[] =>
   inDocumentOrder(tree)
     .flatMap(sequencesOf)
     .flatMap(breaksIn)
-    .sort((left, right) => left.offset - right.offset);
+    .toSorted((left, right) => left.offset - right.offset);

package/src/structure/relative-find.ts

@@ -233,5 +233,5 @@ export const relativeMentions = (
   const bare = bareMentions(text, patterns, vocabulary, number, [...absolute, ...named]);
   return [...named, ...bare]
     .filter((mention) => !substituted.some((span) => span.start <= mention.start && mention.start < span.end))
-    .sort((left, right) => left.start - right.start);
+    .toSorted((left, right) => left.start - right.start);
 };

package/src/structure/relative-resolve.ts

@@ -10,7 +10,13 @@ import type { StructureNode } from "../plugin.ts";
 /** range は「第四十三条から第五十五条まで 削除」のように、一行で並びをまとめたもの。番地は最初のものしか持たない。 */
 type Place = { readonly address: string; readonly level: number; readonly range?: boolean };
 
-type Last = { readonly target: string; readonly document: string | undefined };
+/**
+ * 参照が指した文書: 他の文書の名前と、番号を名指した単位の語。
+ * 単位の語は、見出しに「1 目的」と番号を振った指針の「法第16条」が、条で数える別の文書の条だと決めるのに使う（unit-word.ts）。
+ */
+type Cited = { readonly document: string | undefined; readonly unitWord: string | undefined };
+
+type Last = Cited & { readonly target: string };
 
 const NUMBERED = new Set(["chapter", "article", "item"]);
 
@@ -100,21 +106,21 @@ const continued = (level: number, node: StructureNode, context: Context): Last |
   if (origin === undefined || context.articleLevel === undefined || level < context.articleLevel) return undefined;
   const parts = origin.target.split(".");
   const kept = level - context.articleLevel + 1;
-  return parts.length < kept ? undefined : { target: parts.slice(0, kept).join("."), document: origin.document };
+  return parts.length < kept ? undefined : { ...origin, target: parts.slice(0, kept).join(".") };
 };
 
 /**
  * 参照が名指しした深さを覚える。名指しは、書き出しの深さ（第〇条なら条、前項なら項）から番地の深さまで。
  * 番地を深さで切る起点は条。条より外のまとまりは番地の形が違うので覚えない。
  */
-const remember = (context: Context, target: string, document: string | undefined, from: number): void => {
+const remember = (context: Context, reference: Last, from: number): void => {
   const articleLevel = context.articleLevel;
   // 章・節は番地の形（ch1）が条から始まらないので覚えない。覚えると「同条」が章を指してしまう。
   if (articleLevel === undefined || from < articleLevel) return;
-  const parts = target.split(".");
+  const parts = reference.target.split(".");
   parts.forEach((_, index) => {
     const level = articleLevel + index;
-    if (level >= from) context.last.set(level, { target: parts.slice(0, index + 1).join("."), document });
+    if (level >= from) context.last.set(level, { ...reference, target: parts.slice(0, index + 1).join(".") });
   });
 };
 
@@ -145,12 +151,17 @@ const baseOf = (way: string, node: StructureNode, anchor: Anchor | undefined, la
   return anchor === undefined ? undefined : byPosition(way, Number(node.attrs["count"]), anchor);
 };
 
-/** 同と並びの続きは、元の参照が他の文書を指していれば、それを引き継ぐ。前・次・本はこの文書の中。 */
-const documentOf = (way: string, node: StructureNode, last: Last | undefined, context: Context): string | undefined => {
-  if (way === "same") return last?.document;
-  return way === "continue" ? continued(Number(node.attrs["level"]), node, context)?.document : undefined;
+/** 同と並びの続きは、元の参照が指した文書を引き継ぐ。前・次・本はこの文書の中。 */
+const citedOf = (way: string, node: StructureNode, last: Last | undefined, context: Context): Cited | undefined => {
+  if (way === "same") return last;
+  return way === "continue" ? continued(Number(node.attrs["level"]), node, context) : undefined;
 };
 
+const citedAttrs = (cited: Cited | undefined): Record<string, string> => ({
+  ...(cited?.document === undefined ? {} : { document: cited.document }),
+  ...(cited?.unitWord === undefined ? {} : { unitWord: cited.unitWord }),
+});
+
 const resolveOne = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
   const way = String(node.attrs["relative"]);
   const level = Number(node.attrs["level"]);
@@ -160,12 +171,11 @@ const resolveOne = (node: StructureNode, path: readonly StructureNode[], context
   const place = base === undefined ? undefined : withSuffix(base, String(node.attrs["suffix"] ?? ""), context.implicitLevel);
   if (place === undefined) return undefined;
   const fallback = fallbackOf(place, context.implicitLevel);
-  const document = documentOf(way, node, last, context);
   const attrs = {
     target: place.address,
     label: String(node.attrs["label"]),
     ...(fallback === undefined ? {} : { fallback }),
-    ...(document === undefined ? {} : { document }),
+    ...citedAttrs(citedOf(way, node, last, context)),
   };
   return { ...node, attrs };
 };
@@ -176,17 +186,16 @@ const isRelative = (node: StructureNode): boolean => node.kind === "reference" &
 const walk = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
   if (isRelative(node)) {
     const resolved = resolveOne(node, path, context);
-    const target = resolved === undefined ? undefined : String(resolved.attrs["target"]);
-    const document = optional(resolved?.attrs["document"]);
-    if (target !== undefined) context.byStart.set(node.span.start, { target, document });
-    if (target !== undefined) remember(context, target, document, Number(node.attrs["names"] ?? node.attrs["level"]));
+    if (resolved === undefined) return undefined;
+    const reference = lastOf(resolved);
+    context.byStart.set(node.span.start, reference);
+    remember(context, reference, Number(node.attrs["names"] ?? node.attrs["level"]));
     return resolved;
   }
   if (node.kind === "reference") {
-    const target = String(node.attrs["target"]);
-    const document = optional(node.attrs["document"]);
-    context.byStart.set(node.span.start, { target, document });
-    remember(context, target, document, context.articleLevel ?? 0);
+    const reference = lastOf(node);
+    context.byStart.set(node.span.start, reference);
+    remember(context, reference, context.articleLevel ?? 0);
   }
   const inside = [...path, node];
   const children = node.children.flatMap((child) => {
@@ -198,6 +207,12 @@ const walk = (node: StructureNode, path: readonly StructureNode[], context: Cont
 
 const optional = (value: string | number | undefined): string | undefined => (value === undefined ? undefined : String(value));
 
+const lastOf = (reference: StructureNode): Last => ({
+  target: String(reference.attrs["target"]),
+  document: optional(reference.attrs["document"]),
+  unitWord: optional(reference.attrs["unitWord"]),
+});
+
 const articlesOf = (node: StructureNode): Place[] => {
   const place = node.kind === "article" ? placeOf(node) : undefined;
   return [...(place === undefined ? [] : [place]), ...node.children.flatMap(articlesOf)];

package/src/structure/sexp.ts

@@ -8,7 +8,7 @@ const atom = (value: string | number): string => (typeof value === "number" ? St
 /** 属性はキーの順に並べる。同じ木から毎回同じ文字列を出すため。 */
 const keywords = (node: StructureNode): string[] => [
   ...Object.keys(node.attrs)
-    .sort((left, right) => left.localeCompare(right, "en"))
+    .toSorted((left, right) => left.localeCompare(right, "en"))
     .flatMap((key) => {
       const value = node.attrs[key];
       return value === undefined ? [] : [`:${key} ${atom(value)}`];

package/src/structure/unnumbered.ts

@@ -24,9 +24,9 @@ export const unnumberedUnit = (line: string, open: readonly OpenUnit[], rule: Ru
   if (rule === undefined) return undefined;
   const rest = patternOf(rule.indent).exec(line)?.groups?.["rest"];
   if (rest === undefined) return undefined;
-  const holder = [...open].reverse().find((unit) => unit.numbered.kind === rule.inside);
+  const holder = open.findLast((unit) => unit.numbered.kind === rule.inside);
   if (holder === undefined || !holder.bodyOnLine) return undefined;
-  const previous = [...open].reverse().find((unit) => unit.numbered.depth === rule.depth)?.numbered;
+  const previous = open.findLast((unit) => unit.numbered.depth === rule.depth)?.numbered;
   if (previous !== undefined && previous.label !== "") return undefined;
   const number = String((previous === undefined ? 1 : Number(previous.number)) + 1);
   return { kind: "item", depth: rule.depth, number, absolute: false, label: "", heading: "", rest: rest.trim(), ordinal: Number(number) };

package/src/team-names.ts

@@ -0,0 +1,39 @@
+import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
+
+const SPACE = /\s/u;
+const ESCAPE = /[.*+?^${}()|[\]\\]/gu;
+const WHITESPACE_RUN = String.raw`\s+`;
+const WRAP = String.raw`(?:\r?\n[ \t]*)?`;
+
+/** 名前の中の空白は空白の並びに当て、字と字の間には折り返しの改行を許す。本文の行は好きな所で折れる。 */
+const patternOf = (name: string): RegExp => {
+  const pieces = Array.from(name.trim()).reduce<string[]>((acc, char) => {
+    const previous = acc.at(-1);
+    if (SPACE.test(char)) {
+      if (previous !== WHITESPACE_RUN) acc.push(WHITESPACE_RUN);
+      return acc;
+    }
+    const escaped = char.replace(ESCAPE, "\\$&");
+    if (previous !== undefined && previous !== WHITESPACE_RUN) acc.push(WRAP);
+    acc.push(escaped);
+    return acc;
+  }, []);
+  return new RegExp(pieces.join(""), "gu");
+};
+
+const occurrences = (text: string, name: string): Span[] =>
+  name.trim().length === 0 ? [] : [...text.matchAll(patternOf(name))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/**
+ * チームが chaff.yaml の names に並べた名前が、text のどこにあるか。綴りは書かれたとおり（Apple と apple は別）。
+ * 重なる出現は 1 つの範囲にまとめる。接するだけなら別の名前（並んだ 2 つの名前は 2 つと数える）。位置は text の先頭を 0 とする。
+ */
+export const nameSpans = (text: string, names: readonly string[]): Span[] =>
+  mergeSpans(
+    names.flatMap((name) => occurrences(text, name)),
+    false,
+  );
+
+/** [start, end) が names の範囲のどれかと重なるか。 */
+export const touchesAny = (spans: readonly Span[], start: number, end: number): boolean => spans.some((span) => start < span.end && span.start < end);

package/src/ui.ts

@@ -19,5 +19,12 @@ export const hostLanguage = (configLanguage: string | undefined, env: Readonly<R
   return locale !== undefined && locale.toLowerCase().startsWith("ja") ? "ja" : "en";
 };
 
+/** Several documents end with one closing: in their language when they share one, else the host's. */
+export const sharedLanguage = (languages: readonly string[], host: UiLanguage): UiLanguage => {
+  const distinct = new Set(languages.map((language) => uiLanguageOf(language)));
+  const [only] = [...distinct];
+  return distinct.size === 1 && only !== undefined ? only : host;
+};
+
 /** Text in both languages. Each module keeps its own, next to where it is used. */
 export type Texts<T> = Readonly<Record<UiLanguage, T>>;

package/src/version.ts

@@ -21,7 +21,7 @@ export const versionLines = (raw: unknown): string[] => {
   const dependencies = isRecord(raw) && isRecord(raw["dependencies"]) ? raw["dependencies"] : {};
   const bundled = Object.entries(dependencies)
     .filter((entry): entry is [string, string] => BUNDLED.test(entry[0]) && typeof entry[1] === "string")
-    .sort(([left], [right]) => left.localeCompare(right))
+    .toSorted(([left], [right]) => left.localeCompare(right))
     .map(([name, version]) => `${name} ${version}`);
   return [`chaffjs ${versionOf(raw)}`, ...bundled];
 };

package/src/watch.ts

@@ -7,24 +7,24 @@ const SETTLE_MS = 120;
 export type Snapshot = Readonly<Record<string, number>>;
 
 export const snapshotOf = (findings: readonly Finding[]): Snapshot =>
-  findings.reduce<Record<string, number>>((acc, finding) => ({ ...acc, [finding.rule]: (acc[finding.rule] ?? 0) + 1 }), {});
+  Object.fromEntries(findings.reduce((counts, finding) => counts.set(finding.rule, (counts.get(finding.rule) ?? 0) + 1), new Map<string, number>()));
 
 const total = (snapshot: Snapshot): number => Object.values(snapshot).reduce((sum, count) => sum + count, 0);
 
 /**
  * 差分だけを出す。書いている最中に全件を出し直されると、何が変わったのか分からない。
- * workflow spec §11。
+ * workflow spec §11。`unit` takes the count after the change, which sets the English noun ("0 → 1 finding").
  */
-export const describeChange = (before: Snapshot, after: Snapshot, unit = " 件"): string | undefined => {
+export const describeChange = (before: Snapshot, after: Snapshot, unit: (count: number) => string = () => " 件"): string | undefined => {
   const rules = [...new Set([...Object.keys(before), ...Object.keys(after)])];
   const moved = rules
     .map((rule) => ({ rule, delta: (after[rule] ?? 0) - (before[rule] ?? 0) }))
     .filter((entry) => entry.delta !== 0)
-    .sort((left, right) => left.rule.localeCompare(right.rule, "en"));
+    .toSorted((left, right) => left.rule.localeCompare(right.rule, "en"));
   if (moved.length === 0) return undefined;
   const detail = moved.map((entry) => `${entry.delta > 0 ? "+" : ""}${entry.delta} ${entry.rule}`).join(", ");
   const mark = total(after) < total(before) ? "✓" : "✗";
-  return `${mark} ${total(before)} → ${total(after)}${unit}   (${detail})`;
+  return `${mark} ${total(before)} → ${total(after)}${unit(total(after))}   (${detail})`;
 };
 
 export const clock = (): string => new Date().toTimeString().slice(0, 8);