chaffjs 0.9.0 → 0.11.0

package/src/structure/issues.ts

@@ -30,7 +30,21 @@ const textOf = (node: StructureNode, key: string): string => {
  * 日本語の「第4条第1項」は、番号の無い第 1 項を持つ第4条を指しうる。
  */
 const resolves = (node: StructureNode, addresses: ReadonlySet<string>): boolean =>
-  addresses.has(textOf(node, "target")) || (node.attrs["fallback"] !== undefined && addresses.has(textOf(node, "fallback")));
+  addresses.has(textOf(node, "target")) || (node.attrs["fallback"] !== undefined && addresses.has(fallbackKey(node)));
+
+/**
+ * fallbackLabel があれば、fallback はその見出しの番号で書かれた節点だけに当たる。
+ * 「第3章」の fallback 3 は「## 3. 構成」には当たり、同じ番地の「第3条」には当たらない。
+ */
+const labelled = (address: string, label: string): string => `${address}\u0000${label}`;
+const fallbackKey = (node: StructureNode): string =>
+  node.attrs["fallbackLabel"] === undefined ? textOf(node, "fallback") : labelled(textOf(node, "fallback"), textOf(node, "fallbackLabel"));
+
+/** 見出しの下の章（h1/ch9）は、見出しの番地を除いた ch9 でも指せる。本文の「第9章」は見出しの番地を書かない。 */
+const addressesOf = (node: StructureNode): string[] =>
+  node.kind === "chapter" && node.address.includes("/") ? [node.address, node.address.slice(node.address.lastIndexOf("/") + 1)] : [node.address];
+
+const keysOf = (node: StructureNode): string[] => addressesOf(node).flatMap((address) => [address, labelled(address, textOf(node, "label"))]);
 
 /**
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
@@ -40,7 +54,7 @@ export const danglingReferences = (tree: StructureNode): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   if (!nodes.some((node) => node.kind === "article")) return [];
-  const addresses = new Set(nodes.filter((node) => NUMBERED.includes(node.kind)).map((node) => node.address));
+  const addresses = new Set(nodes.filter((node) => NUMBERED.includes(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"];

package/src/structure/of.ts

@@ -1,6 +1,7 @@
 import { markdownOutline } from "../document.ts";
 import type { DocumentProfile, StructureNode, StructurePatterns } from "../plugin.ts";
-import { buildTree, NO_OUTLINE } from "./build.ts";
+import { buildTree } from "./build.ts";
+import { textOutline } from "../page-furniture.ts";
 
 export type SourceInput = {
   readonly path: string;
@@ -20,7 +21,8 @@ export const buildStructure = (input: SourceInput, patterns: StructurePatterns):
       path: input.path,
       source: input.source,
       language: input.language,
-      outline: input.markdown ? markdownOutline(input.source) : NO_OUTLINE,
+      outline: input.markdown ? markdownOutline(input.source) : textOutline(input.source),
+      markdown: input.markdown,
       profile: input.profile,
     },
     patterns,

package/src/structure/relative-find.ts

@@ -105,6 +105,19 @@ const substitutionSpans = (text: string, quote: Substitution | undefined): Span[
         (span) => quote.after.some((marker) => text.startsWith(marker, span.end)) || quote.before.some((marker) => text.slice(0, span.start).endsWith(marker)),
       );
 
+/** 読み替えの括弧の中の、文書を名指ししていない参照に、読み替える先の文書の名前を付ける。 */
+export const substitutedDocuments = (mentions: readonly Mention[], text: string, profile: DocumentProfile | undefined): readonly Mention[] => {
+  const quote = profile?.relative?.substitution;
+  const document = quote?.document;
+  if (document === undefined) return mentions;
+  const spans = substitutionSpans(text, quote);
+  return mentions.map((mention) =>
+    mention.attrs["document"] === undefined && spans.some((span) => span.start <= mention.start && mention.start < span.end)
+      ? { ...mention, attrs: { ...mention.attrs, document } }
+      : mention,
+  );
+};
+
 /** 閉じた括弧書きを内側から外す。 */
 const withoutAsides = (gap: string, aside: RelativeVocabulary["aside"]): string => {
   if (aside === undefined) return gap;

package/src/structure/runs.ts

@@ -0,0 +1,71 @@
+/**
+ * 箇条書きと表の行の並び。続いた箇条書きの同じ深さの項目か、続いた表の行を一つの並びとして読む。
+ * 並びの中の値（日付、金額）を比べる rule が共通に使う。
+ */
+type Kind = "list" | "table";
+
+const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+const TABLE_ROW = /^[ \t]{0,12}\|/u;
+
+const TABLE_RULE = /^[ \t]{0,12}\|?[ \t]{0,4}:?-{3,}/u;
+const INDENT = /^[ \t]*/u;
+
+export type Line = { readonly start: number; readonly end: number; readonly kind: Kind | undefined; readonly indent: number; readonly rule: boolean };
+
+const kindOf = (text: string): Kind | undefined => {
+  if (TABLE_ROW.test(text)) return "table";
+  return LIST_ITEM.test(text) ? "list" : undefined;
+};
+
+/** 先頭に | を書かない表（「Step | Date」「--- | ---」）の行。| のある見出しの下の区切り行から、| のある行が続くあいだ。 */
+const PIPELESS_RULE = /^[ \t]{0,12}:?-{3,}:?[ \t]{0,4}\|/u;
+
+const pipelessTableLines = (texts: readonly string[]): Set<number> => {
+  const inTable = new Set<number>();
+  texts.forEach((text, index) => {
+    if (!PIPELESS_RULE.test(text) || !(texts[index - 1] ?? "").includes("|")) return;
+    for (let row = index + 1; row < texts.length && (texts[row] ?? "").includes("|"); row += 1) inTable.add(row);
+  });
+  return inTable;
+};
+
+const linesOf = (source: string): Line[] => {
+  const texts = source.split("\n");
+  const pipeless = pipelessTableLines(texts);
+  const found: Line[] = [];
+  let start = 0;
+  texts.forEach((text, index) => {
+    const indent = INDENT.exec(text)?.[0].length ?? 0;
+    const kind = pipeless.has(index) ? "table" : kindOf(text);
+    found.push({ start, end: start + text.length, kind, indent, rule: TABLE_RULE.test(text) });
+    start += text.length + 1;
+  });
+  return found;
+};
+
+/**
+ * 続いた箇条書きや表の中で、同じ深さの行を一つの並びにする。
+ * 子の項目（深い字下げ）は親の並びを切らずに、親ごとに別の並びになる。浅い項目が来たら、それより深い並びは閉じる。
+ * 表の区切り行（|---|）のすぐ前の行は見出しなので、並びから外す。
+ */
+export const runsOf = (source: string): Line[][] => {
+  const runs: Line[][] = [];
+  const open = new Map<number, Line[]>();
+  const close = (deeperThan: number): void => [...open.keys()].filter((depth) => depth > deeperThan).forEach((depth) => open.delete(depth));
+  linesOf(source).forEach((line, index, all) => {
+    if (line.kind === undefined || all[index - 1]?.kind !== line.kind) close(-1);
+    if (line.kind === undefined) return;
+    if (line.rule) {
+      open.get(line.indent)?.pop();
+      return;
+    }
+    close(line.indent);
+    const run = open.get(line.indent) ?? [];
+    if (!open.has(line.indent)) {
+      open.set(line.indent, run);
+      runs.push(run);
+    }
+    run.push(line);
+  });
+  return runs;
+};

package/src/structure/total.ts

@@ -0,0 +1,183 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
+
+/**
+ * 合計の行と、その上に並べた金額の和。箇条書きの続いた項目か、表の続いた行で、合計の語（合計・小計・Total）で始まる行を読む。
+ * 同じ単位で同じ列（箇条書きは一つの列）の金額を上から足し、合計の行の金額と合わなければ言う。
+ * 小計と税のあとの総計のように、足し方が何通りかある。どの足し方でも合わないときだけ言う。
+ * 表の升に数だけを書いた列（単位は見出しにある）も足す。そのときは上の行の升がどれも数でなければ足さない。年や番号の列を足さないため。
+ */
+export type Amount = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: string };
+
+const CENTS = 100;
+
+/** 区切りのコンマを書かずに 4 桁以上続けた整数部（1205、1205.50）。 */
+const UNGROUPED = /(?<![\d.])\d{4}/u;
+const MIN_PARTS = 2;
+
+/** 金額の前に書いた負の印（-500、▲500、-$500）。行頭の箇条書きの - は印にしない。 */
+const NEGATIVE_BEFORE = /[-−▲△][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+
+/** 括弧に入れた金額（(1,200)）。会計では負の数だが、補足の金額とも読めて符号が決まらない。 */
+const OPEN_PAREN_BEFORE = /[(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+
+type Cell = { readonly column: number; readonly unit: string };
+/** cents が undefined の金額は、符号が決まらない。 */
+type Placed = Amount & Cell & { readonly cents: number | undefined };
+type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
+
+const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
+
+const isNegative = (source: string, line: Line, amount: Amount): boolean => {
+  const before = source.slice(line.start, amount.offset);
+  const marker = NEGATIVE_BEFORE.exec(before);
+  return marker !== null && before.slice(0, marker.index).trim().length > 0;
+};
+
+/** 行の最初の文字列（表なら最初の列）から、強調の印と箇条書きの印を除いたもの。 */
+const leadingText = (text: string): string =>
+  text
+    .replace(/^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*\|?[ \t]*/u, "")
+    .replace(/^[*_]+/u, "")
+    .trimStart();
+
+/**
+ * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、括弧の注記（合計（税込））、金額。
+ * 「計画」や「Total conversion: 25%」のように語が続くものは合計の行ではない。
+ */
+const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
+
+const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
+  const lead = leadingText(text).toLowerCase();
+  return labels.some((label) => lead.startsWith(label.toLowerCase()) && AFTER_LABEL.test(lead.slice(label.length)));
+};
+
+const centsOf = (source: string, line: Line, amount: Amount): number | undefined => {
+  if (OPEN_PAREN_BEFORE.test(source.slice(line.start, amount.offset))) return undefined;
+  return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
+};
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], labels: readonly string[]): Entry => ({
+  label: isTotalLabel(source.slice(line.start, line.end), labels),
+  amounts: amounts
+    .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
+    .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
+});
+
+const sameCell = (a: Cell, b: Cell): boolean => a.column === b.column && a.unit === b.unit;
+
+const sumOf = (values: readonly number[]): number => values.reduce((sum, value) => sum + value, 0);
+
+type RowsAbove = { readonly parts: number[]; readonly totals: number[]; sinceLast: number[] };
+
+/**
+ * 行の中で、その列と単位の値。無ければ null、二つ以上あるか、列に別の単位しか無いか、符号が決まらなければ undefined。
+ * 数だけの列では、数の無い升（空、文字、括弧）も undefined。
+ */
+const valueIn = (entry: Entry, cell: Cell): number | null | undefined => {
+  const inColumn = entry.amounts.filter((amount) => amount.column === cell.column);
+  const matching = inColumn.filter((amount) => sameCell(amount, cell));
+  if (matching.length === 0) return inColumn.length === 0 && cell.unit !== NO_UNIT ? null : undefined;
+  return matching.length === 1 ? matching[0]?.cents : undefined;
+};
+
+const addTo = (above: RowsAbove, entry: Entry, value: number): void => {
+  if (entry.label) {
+    above.totals.push(value);
+    above.sinceLast = [];
+    return;
+  }
+  above.parts.push(value);
+  above.sinceLast.push(value);
+};
+
+/**
+ * 合計の行より上の、同じ列と単位の値。項目の行と合計の行に分け、最後の合計の行より後の項目も取る。
+ * 足し方が決まらない行（valueIn が undefined）が一つでもあれば undefined。1.2万円と円のように単位が割れた列もここで止まる。
+ */
+const windowAbove = (entries: readonly Entry[], cell: Cell): RowsAbove | undefined => {
+  const values = entries.map((entry) => valueIn(entry, cell));
+  if (values.includes(undefined)) return undefined;
+  const above: RowsAbove = { parts: [], totals: [], sinceLast: [] };
+  entries.forEach((entry, index) => {
+    const value = values[index];
+    if (typeof value === "number") addTo(above, entry, value);
+  });
+  return above;
+};
+
+/** 足し方の候補: 上の項目すべて（小計を並べた総計もこれ）、最後の合計より後の項目、最後の合計にその後の項目。項目が無ければ小計の和だけ。 */
+const candidateSums = (above: RowsAbove): number[] => {
+  if (above.parts.length === 0) return [sumOf(above.totals)];
+  const last = above.totals.at(-1);
+  return [sumOf(above.parts), sumOf(above.sinceLast), ...(last === undefined ? [] : [last + sumOf(above.sinceLast)])];
+};
+
+/** 項目が無く小計だけが並ぶ表は、小計の和。 */
+const reportedSum = (above: RowsAbove): number => (above.parts.length === 0 ? sumOf(above.totals) : (above.totals.at(-1) ?? 0) + sumOf(above.sinceLast));
+
+/** 和と呼べるだけの行があるか。項目が二つ以上か、項目が無く小計が二つ以上。 */
+const enoughRows = (above: RowsAbove): boolean => above.parts.length >= MIN_PARTS || (above.parts.length === 0 && above.totals.length >= MIN_PARTS);
+
+/** 和は、合計の行と同じ小数の桁と区切りで見せる（$10,160.00 なら $10,260.00、1205 なら 1305）。端数があれば 2 桁。 */
+const formatCents = (cents: number, written: string): string => {
+  const digits = Math.max(/\.\d{2}/u.test(written) ? 2 : 0, cents % CENTS === 0 ? 0 : 2);
+  const useGrouping = !UNGROUPED.test(written);
+  return (cents / CENTS).toLocaleString("en-US", { minimumFractionDigits: digits, maximumFractionDigits: digits, useGrouping });
+};
+
+/** 数の前に書いた単位（$1,200、$ 1,200）の始まり。木の数量は数から始まるので、見せるときは前の単位も入れる。 */
+const unitStartBefore = (source: string, amount: Amount): number | undefined => {
+  if (amount.unit === NO_UNIT) return undefined;
+  const gap = /[ \t]/u.test(source[amount.offset - 1] ?? "") ? 1 : 0;
+  const start = amount.offset - gap - amount.unit.length;
+  return start >= 0 && source.slice(start, amount.offset - gap) === amount.unit ? start : undefined;
+};
+
+/** 負の金額の前に書いた印（-、▲）。見せる金額に入れる。 */
+const SIGN_BEFORE = /[-−▲△][ \t]?$/u;
+const SIGN_REACH = 2;
+
+const signBefore = (source: string, total: Placed, start: number): string =>
+  total.cents !== undefined && total.cents < 0 ? (SIGN_BEFORE.exec(source.slice(Math.max(0, start - SIGN_REACH), start))?.[0] ?? "") : "";
+
+/** 合計の行に書いた金額と、上の和を、同じ書き方で見せる。負の和には、合計に書いた印（無ければ -）を付ける。 */
+const shownAmounts = (source: string, total: Placed, sumCents: number): Record<string, string> => {
+  const unitStart = unitStartBefore(source, total);
+  const start = unitStart ?? total.offset;
+  const sign = signBefore(source, total, start);
+  const written = source.slice(start - sign.length, total.end);
+  const sumSign = sumCents < 0 ? sign || "-" : "";
+  const sum = formatCents(Math.abs(sumCents), written);
+  if (unitStart !== undefined) return { written, sum: `${sumSign}${source.slice(unitStart, total.offset)}${sum}` };
+  return { written, sum: `${sumSign}${sum}${written.endsWith(total.unit) ? total.unit : ""}` };
+};
+
+/**
+ * 数だけの列で、合計の行の数が項目のどれかより大きくなければ、和ではなく平均や率や年の列と読んで足さない。
+ * 項目に負の数があれば、和が項目より小さいこともあるので足す。
+ */
+const readsAsSum = (cell: Cell, writtenCents: number, above: RowsAbove): boolean =>
+  cell.unit !== NO_UNIT || above.parts.some((part) => part < 0) || above.parts.every((part) => part < writtenCents);
+
+const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
+  entries.flatMap((entry, index) => {
+    if (!entry.label) return [];
+    return entry.amounts.flatMap((total) => {
+      const writtenCents = valueIn(entry, total);
+      const above = windowAbove(entries.slice(0, index), total);
+      if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || !readsAsSum(total, writtenCents, above)) return [];
+      if (candidateSums(above).includes(writtenCents)) return [];
+      return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
+    });
+  });
+
+export const totalMismatches = (source: string, amounts: readonly Amount[], labels: readonly string[]): StructureIssue[] =>
+  runsOf(source).flatMap((run) => {
+    const inRun = [...amounts, ...bareNumbersIn(source, run)];
+    return mismatchesIn(
+      source,
+      run.map((line) => entryOf(source, line, inRun, labels)),
+    );
+  });

package/src/structure/universal.ts

@@ -7,15 +7,26 @@ import type { NumberedLine, NumberingContext } from "../plugin.ts";
 const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})\.?[ \t\u3000]+(?<rest>\S.*)$/u;
 
 /**
- * 本文の「1. 」は箇条書きで、見出しの「1. 」は章番号。点を含まない番号は、見出しの行でだけ読む。
+ * RFC のようなテキストの仕様書（Markdown でないもの）の章見出し「5.  Security Considerations」。Markdown では、行内のコードを伏せた空白が
+ * 同じ形に見えるので読まない。行頭から、点の後ろに空白が 2 つ以上あり、
+ * 見出しは文として終わらない（句点・ピリオド・読点で終わらない）短い語句。箇条書きの「1. 」は空白 1 つで、文で終わる。
+ */
+const TOP_SECTION = /^\d{1,3}\. {2,}\S/u;
+const SENTENCE_END = /[.。:;,、!?！？]$/u;
+const MAX_TITLE = 80;
+
+const isTopSection = (line: string, rest: string): boolean => TOP_SECTION.test(line) && rest.length <= MAX_TITLE && !SENTENCE_END.test(rest);
+
+/**
+ * 本文の「1. 」は箇条書きで、見出しの「1. 」は章番号。点を含まない番号は、見出しの行か、テキストの章見出しの形でだけ読む。
  * 「4.2 」のように点を含むものは、.txt の仕様書でも見出しとして書かれるので本文でも読む。
  */
-export const dottedNumber = (line: string, context: NumberingContext): NumberedLine | undefined => {
+export const dottedNumber = (line: string, context: NumberingContext, plainText = false): NumberedLine | undefined => {
   const groups = DOTTED.exec(line)?.groups;
   const number = groups?.["number"];
   if (number === undefined) return undefined;
   const depth = number.split(".").length;
-  if (depth < 2 && !context.isHeading) return undefined;
   const rest = groups?.["rest"]?.trim() ?? "";
+  if (depth < 2 && !context.isHeading && !(plainText && isTopSection(line, rest))) return undefined;
   return { kind: "article", depth, number, absolute: true, label: number, heading: rest, rest, ordinal: Number(number.split(".").at(-1)) };
 };

package/src/structure/unnumbered.ts

@@ -0,0 +1,33 @@
+import type { DocumentProfile, NumberedLine } from "../plugin.ts";
+
+/** 開いている単位と、その行の番号の後ろが本文だったか（見出しでなく）。見出しは前の行から付くことがあるので、行そのものを覚えておく。 */
+export type OpenUnit = { readonly numbered: NumberedLine; readonly bodyOnLine: boolean };
+
+type Rule = NonNullable<DocumentProfile["unnumbered"]>;
+
+const escape = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+const compiled = new Map<string, RegExp>();
+
+const patternOf = (indent: string): RegExp => {
+  const found = compiled.get(indent) ?? new RegExp(`^${escape(indent)}(?<rest>\\S.*)$`, "u");
+  compiled.set(indent, found);
+  return found;
+};
+
+/**
+ * 番号を書かない単位（古い法令は第 2 項以降に番号を振らず、字下げした行を新しい項にする）。
+ * inside の種類の単位の行に本文が続くときだけ、その中で開いている depth の単位の次（無ければ 2 番目）として読む。
+ * 番号を書いた単位（「２」）がすでにあれば、字下げは番号の代わりではない。
+ */
+export const unnumberedUnit = (line: string, open: readonly OpenUnit[], rule: Rule | undefined): NumberedLine | undefined => {
+  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);
+  if (holder === undefined || !holder.bodyOnLine) return undefined;
+  const previous = [...open].reverse().find((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/structure/weekday.ts

@@ -0,0 +1,25 @@
+import type { StructureNode } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { inDocumentOrder } from "./issues.ts";
+
+// 日付と、その横に書いた曜日の食い違い。暦で決まるので、両方読めれば誤りは機械で言える。
+
+const FULL_DATE = /^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/u;
+
+/** 暦の曜日。日曜日が 0。存在しない日（2月30日）は undefined。 */
+export const weekdayOf = (value: string): number | undefined => {
+  const groups = FULL_DATE.exec(value)?.groups;
+  if (groups === undefined) return undefined;
+  const [year, month, day] = [Number(groups["y"]), Number(groups["m"]), Number(groups["d"])];
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date.getUTCDay() : undefined;
+};
+
+/** 年まで書いた日付で、書いた曜日が暦と違うもの。年の無い日付は曜日を決められないので見ない。 */
+export const weekdayMismatches = (tree: StructureNode): StructureIssue[] =>
+  inDocumentOrder(tree).flatMap((node) => {
+    const written = node.attrs["weekday"];
+    if (node.kind !== "date" || typeof written !== "number") return [];
+    const actual = weekdayOf(String(node.attrs["value"]));
+    return actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: String(node.attrs["value"]), written, actual } }];
+  });

package/src/version.ts

@@ -8,7 +8,25 @@ import { dirname, join } from "node:path";
  */
 const MANIFEST = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
 
-const versionOf = (raw: unknown): string =>
-  typeof raw === "object" && raw !== null && "version" in raw && typeof raw.version === "string" ? raw.version : "0.0.0";
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
-export const VERSION = versionOf(JSON.parse(readFileSync(MANIFEST, "utf8")));
+const versionOf = (raw: unknown): string => (isRecord(raw) && typeof raw["version"] === "string" ? raw["version"] : "0.0.0");
+
+const BUNDLED = /^@chaffjs\/lang-/u;
+
+/**
+ * `chaff --version` の行。chaffjs と、同梱の言語パッケージ。chaffjs は言語パッケージをちょうどの版で依存に書くので、manifest がそのまま答え。
+ */
+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))
+    .map(([name, version]) => `${name} ${version}`);
+  return [`chaffjs ${versionOf(raw)}`, ...bundled];
+};
+
+const manifest: unknown = JSON.parse(readFileSync(MANIFEST, "utf8"));
+
+export const VERSION = versionOf(manifest);
+export const VERSION_LINES = versionLines(manifest);