chaffjs 0.14.0 → 0.15.0

package/src/soft-break.ts

@@ -0,0 +1,94 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 段落の中の改行のうち、読み手には見えないもの。
+ *
+ * Markdown は段落の中の改行を空白として表示するが、全角の文字に挟まれた改行は空白にもならずに消える
+ * （CSS Text 3 の segment break transformation。ブラウザがそう描く）。日本語は語の間に空白を置かないので、
+ * PDF から写した判決や、行の途中で折り返して書いた段落をそのまま解析器に渡すと、改行が語を割る（「関」「する」）。
+ * 英字・数字・ハングルに接する改行は、読み手にも空白に見えるので残す。
+ */
+const WIDE = /[\p{scx=Han}\p{scx=Hiragana}\p{scx=Katakana}、-〿！-｠￠-￦]/u;
+
+const NEWLINE = /\n/gu;
+const isHorizontalSpace = (unit: string | undefined): boolean => unit === " " || unit === "\t";
+
+/** 改行の前に空白が 2 つ以上あれば、Markdown の強制改行（hard line break）。読み手にも改行に見える。 */
+const HARD_BREAK_SPACES = 2;
+
+const isLowSurrogate = (unit: number): boolean => unit >= 0xdc00 && unit <= 0xdfff;
+
+/** index の直前の 1 文字（サロゲートペアは 2 単位で 1 文字）。 */
+const charBefore = (text: string, index: number): string => {
+  const width = index >= 2 && isLowSurrogate(text.charCodeAt(index - 1)) ? 2 : 1;
+  return text.slice(Math.max(0, index - width), index);
+};
+
+const charAt = (text: string, index: number): string => {
+  const point = text.codePointAt(index);
+  return point === undefined ? "" : String.fromCodePoint(point);
+};
+
+/** 改行を挟む 2 文字が、改行を消して読む組か。 */
+export const joinsAcrossBreak = (before: string, after: string): boolean => WIDE.test(before) && WIDE.test(after);
+
+/** from から back の向きに、空白（スペース・タブ）が続く先。 */
+const spacesUntil = (text: string, from: number, step: 1 | -1): number => {
+  let at = from;
+  while (isHorizontalSpace(text[step === 1 ? at : at - 1])) at += step;
+  return at;
+};
+
+/** 改行 1 つと、その前の行末・後ろの行頭の空白。正規表現で取ると、空白の長い並びで後戻りが増える。 */
+const lineBreakAt = (text: string, newline: number): { readonly span: Span; readonly trailingSpaces: number } => {
+  const lineEnd = text[newline - 1] === "\r" ? newline - 1 : newline;
+  const start = spacesUntil(text, lineEnd, -1);
+  return { span: { start, end: spacesUntil(text, newline + 1, 1) }, trailingSpaces: lineEnd - start };
+};
+
+const isSoft = (text: string, found: { readonly span: Span; readonly trailingSpaces: number }): boolean =>
+  found.trailingSpaces < HARD_BREAK_SPACES && joinsAcrossBreak(charBefore(text, found.span.start), charAt(text, found.span.end));
+
+/** text の中の、消える改行（前後の行頭・行末の空白ごと）。text の文字だけで決める。 */
+export const softBreaks = (text: string): Span[] =>
+  [...text.matchAll(NEWLINE)]
+    .map((match) => lineBreakAt(text, match.index))
+    .filter((found) => isSoft(text, found))
+    .map((found) => found.span);
+
+/**
+ * 覆った文字（コード・リンクの記号・URL）に触れない、消える改行。source と prose は同じ長さで、同じ位置に同じ文字がある。
+ *
+ * 覆った文字は空白になっているので、prose だけでは行頭のインデントとインラインコードの跡を見分けられない。
+ * 見分けずにつなぐと、行頭の `npm` の前後の語が 1 語になる。
+ */
+export const unmaskedSoftBreaks = (source: string, prose: string): Span[] =>
+  softBreaks(prose).filter((span) => source.slice(span.start, span.end) === prose.slice(span.start, span.end));
+
+/** breaks（text の中の範囲、昇順・重ならない）を取り除いた文字列。 */
+export const withoutSpans = (text: string, breaks: readonly Span[]): string => {
+  const parts: string[] = [];
+  const cursor = breaks.reduce((from, span) => {
+    parts.push(text.slice(from, span.start));
+    return span.end;
+  }, 0);
+  parts.push(text.slice(cursor));
+  return parts.join("");
+};
+
+/** sorted（昇順・重ならない）の中で、end が offset より後ろの最初の添字。無ければ sorted.length。 */
+export const firstEndingAfter = (sorted: readonly Span[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (sorted[middle]?.end ?? Number.POSITIVE_INFINITY) > offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, sorted.length);
+};
+
+/** sorted（昇順・重ならない）のうち、outer に収まるもの。段落や文ごとに全部をなめない。 */
+export const spansWithin = <T extends Span>(sorted: readonly T[], outer: Span): T[] => {
+  const from = firstEndingAfter(sorted, outer.start);
+  const to = firstEndingAfter(sorted, outer.end);
+  return sorted.slice(from, to).filter((span) => span.start >= outer.start);
+};

package/src/structure/build.ts

@@ -7,8 +7,10 @@ import { maskSpans } from "../mask.ts";
 import type { DocumentProfile, Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { dottedNumber } from "./universal.ts";
+import { numberInSentence } from "./number-in-sentence.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
+import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -129,11 +131,14 @@ const outsideAddresses = (mentions: readonly Mention[], text: string, profile: D
 const withoutAbsolute = (relative: readonly Mention[], absolute: readonly Mention[]): readonly Mention[] =>
   relative.filter((mention) => !absolute.some((other) => mention.start < other.end && other.start < mention.end));
 
-type LeafFinder = (patterns: StructurePatterns, text: string, profile: DocumentProfile | undefined) => readonly Mention[];
+type LeafFinder = (patterns: StructurePatterns, text: string, profile: DocumentProfile | undefined, wrapped: WrappedLine) => readonly Mention[];
 
 const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder }[] = [
   { kind: "definition", find: (patterns, text) => patterns.definitions(text) },
-  { kind: "reference", find: (patterns, text, profile) => substitutedDocuments(patterns.references(text), text, profile) },
+  {
+    kind: "reference",
+    find: (patterns, _text, profile, wrapped) => onLine(substitutedDocuments(patterns.references(wrapped.text), wrapped.text, profile), wrapped),
+  },
   {
     kind: "reference",
     find: (patterns, text, profile) => {
@@ -146,10 +151,12 @@ const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder
   { kind: "date", find: (patterns, text) => patterns.dates?.(text) ?? [] },
 ];
 
-/** 言語を問わない通し番号。後ろが単位なら数量なので番号にしない。 */
+/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
 const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
   const dotted = dottedNumber(text, context, plainText);
-  return dotted !== undefined && patterns.countedAfter?.(dotted.number, dotted.rest) === true ? undefined : dotted;
+  if (dotted === undefined || patterns.countedAfter?.(dotted.number, dotted.rest) === true) return undefined;
+  const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
+  return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
 };
 
 /** 行の中の定義・参照・義務・数量を、いま開いている最も内側の節点の子にする。 */
@@ -180,12 +187,13 @@ const scopeOf = (state: State, patterns: StructurePatterns, text: string): Reado
   return within === undefined ? { scope: "local" } : { scope: "local", within: within.address };
 };
 
-const addLeaves = (state: State, patterns: StructurePatterns, line: Line, text: string, offset: number, onHeading: boolean): void => {
+const addLeaves = (state: State, patterns: StructurePatterns, line: Line, wrapped: WrappedLine, offset: number, onHeading: boolean): void => {
   const parent = top(state).draft;
+  const text = wrapped.line;
   const scope = scopeOf(state, patterns, text);
   const leaves = LEAVES.filter(({ kind }) => !onHeading || readsOnHeading(kind))
     .flatMap(({ kind, find }) =>
-      find(patterns, text, state.profile).map((mention) => ({
+      find(patterns, text, state.profile, wrapped).map((mention) => ({
         kind,
         start: line.start + offset + mention.start,
         end: line.start + offset + mention.end,
@@ -290,7 +298,7 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
   return numbered === undefined || caption === undefined ? numbered : { ...numbered, heading: caption };
 };
 
-const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined): void => {
+const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, next: string | undefined): void => {
   const text = heading === undefined ? line.text : headingLineText(line.text);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
@@ -306,7 +314,8 @@ const readLine = (state: State, patterns: StructurePatterns, line: Line, heading
   // 番号付きの行は番号の後ろだけを読む。「第3条（支払）」の「第3条」を自分への参照として拾わない。
   const scanned = numbered === undefined ? text : numbered.rest;
   const offset = Math.max(0, line.text.lastIndexOf(scanned));
-  if (scanned !== "") addLeaves(state, patterns, line, scanned, offset, heading !== undefined);
+  const onHeading = heading !== undefined;
+  if (scanned !== "") addLeaves(state, patterns, line, wrappedLine(scanned, onHeading, next), offset, onHeading);
 };
 
 /**
@@ -331,8 +340,8 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
     captions: new Map(),
     plainText: !input.markdown,
   };
-  lines.forEach((line) => {
-    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number));
+  lines.forEach((line, index) => {
+    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number), lines[index + 1]?.text);
     // コードの行は覆って読まないが、開いている節の中身ではある。節の最後にコードブロックがあっても、範囲をそこまで伸ばす。
     else if (input.source.slice(line.start, line.start + line.text.length).trim() !== "") extend(state, line.start + line.text.length);
   });

package/src/structure/date-order.ts

@@ -5,6 +5,7 @@ import { runsOf, type Line } from "./runs.ts";
  * 日程として並べた日付の順番。箇条書きの続いた項目か、表の続いた行で、日付をちょうど一つ持つものを並びとして読む。
  * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩だけを言う。新しい順に並べた履歴は正しい並び。
  * 向きが決まらない並び（上がりと下がりが同じ数）は何も言わない。逆らう一歩を言えるのは、日付が 4 つ以上の並びだけになる。
+ * 向きに沿って並ぶ日付が半分以下の並びは、日付でなく別のもの（名前、版）で並べた一覧として何も言わない。
  */
 export type DatedPoint = { readonly offset: number; readonly value: string };
 
@@ -23,6 +24,19 @@ const samePrecision = (dated: readonly DatedPoint[]): boolean => PRECISIONS.some
 /** 上がりが多ければ 1、下がりが多ければ -1、同じ数なら 0（向きを決めない）。 */
 const majorityOf = (up: number, down: number): number => Math.sign(up - down);
 
+/** 向きに沿って並べられる日付の最大の数（間を飛ばしてよい。等しい日付は向きに逆らわない）。 */
+export const longestInOrder = (values: readonly string[], direction: number): number =>
+  Math.max(
+    0,
+    ...values.reduce<number[]>((lengths, value, index) => {
+      const along = values.slice(0, index).map((earlier, at) => (Math.sign(value.localeCompare(earlier)) === -direction ? 0 : (lengths[at] ?? 0)));
+      return [...lengths, 1 + Math.max(0, ...along)];
+    }, []),
+  );
+
+/** 日付のうち向きに沿うものが過半を占める。ひとつふたつの書き間違いなら残りが揃うが、名前順の一覧は揃わない。 */
+const mostlyInOrder = (values: readonly string[], direction: number): boolean => longestInOrder(values, direction) * 2 > values.length;
+
 /** 多いほうの向きに逆らう一歩。後ろの項目の日付を指す。 */
 const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
   const steps = dated
@@ -31,7 +45,8 @@ const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
   const up = steps.filter((step) => step.sign > 0).length;
   const down = steps.filter((step) => step.sign < 0).length;
   const majority = majorityOf(up, down);
-  if (majority === 0) return [];
+  const values = dated.map((point) => point.value);
+  if (majority === 0 || !mostlyInOrder(values, majority)) return [];
   return steps
     .filter((step) => step.sign === -majority)
     .map((step) => ({ offset: step.point.offset, values: { date: step.point.value, previous: step.previous?.value ?? "" } }));

package/src/structure/issues.ts

@@ -1,4 +1,6 @@
 import type { StructureNode } from "../plugin.ts";
+import { listedTags } from "./listed-tags.ts";
+import { namesAbsentUnit } from "./unit-word.ts";
 
 // 木だけで決まる誤り。参照先が無い、番号が飛ぶ・重なる、同じ語を二度定義する。
 // 意味の食い違いは判定しない。書いてあることから機械で決まるものだけを出す。
@@ -46,24 +48,37 @@ const addressesOf = (node: StructureNode): string[] =>
 
 const keysOf = (node: StructureNode): string[] => addressesOf(node).flatMap((address) => [address, labelled(address, textOf(node, "label"))]);
 
+/**
+ * 他の文書を指す参照か。citedTag（"[HTTP-CACHING]"）は、書き方だけでは差し込み欄の "[BUYER-1]" と見分けられないので、
+ * 文書がその語を一覧に載せているときだけ他の文書の名とみなす。
+ */
+const citesOtherDocument =
+  (listed: ReadonlySet<string>) =>
+  (node: StructureNode): boolean =>
+    node.attrs["document"] !== undefined || (node.attrs["citedTag"] !== undefined && listed.has(textOf(node, "citedTag")));
+
 /**
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
  * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
-export const danglingReferences = (tree: StructureNode): StructureIssue[] => {
+export const danglingReferences = (tree: StructureNode, source: string): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   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));
   // 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" && node.attrs["document"] !== undefined).map(numbering));
+  const citedElsewhere = new Set(nodes.filter((node) => node.kind === "reference" && citesOther(node)).map(numbering));
   const otherNumbering = (node: StructureNode): boolean =>
     numberings.size > 0 && typeof numbering(node) === "string" && !numberings.has(String(numbering(node))) && citedElsewhere.has(numbering(node));
+  const articleLabels = nodes.filter((node) => node.kind === "article").map((node) => textOf(node, "label"));
   return nodes
-    .filter((node) => node.kind === "reference" && node.attrs["document"] === undefined && !otherNumbering(node))
+    .filter((node) => node.kind === "reference" && !citesOther(node) && !otherNumbering(node))
+    .filter((node) => !namesAbsentUnit(node, articleLabels))
     .filter((node) => !resolves(node, addresses))
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };

package/src/structure/listed-tags.ts

@@ -0,0 +1,7 @@
+// 角括弧の見出し語を、文書が一覧に載せているか。一覧の項目は行頭の [語] で始まり、その後ろは行末か、
+// 2 つ以上の空白かタブで本文と離れる（ぶら下げの組み方）。行頭の [語] に空白 1 つで文が続くのは本文。
+
+const LISTED = /^[ \t]*\[(?<tag>[^[\]\s]{1,60})\](?:[ \t]*\r?$|[ \t]{2,}|\t)/u;
+
+/** 文書が一覧の項目として載せている角括弧の見出し語（括弧を除く）。 */
+export const listedTags = (source: string): ReadonlySet<string> => new Set(source.split("\n").flatMap((line) => LISTED.exec(line)?.groups?.["tag"] ?? []));

package/src/structure/number-in-sentence.ts

@@ -0,0 +1,20 @@
+/** 大文字と小文字のある文字で、小文字の語。節の題（「3.1 Scope」「4.2 The Supplier shall」）は小文字で始まらない。 */
+const LOWERCASE_WORD = /^\p{Ll}/u;
+
+/** 文の終わり。ピリオドは後ろが空白か行末のとき（「3.x」「e-Tax.nta」の点は文を終えない）。題は文として終わらない。 */
+const SENTENCE_END = /[.!?](?=\s|$)|[。！？]/u;
+
+/** 行頭の通し番号の行。rest は番号の後ろ。 */
+export type NumberedText = { readonly number: string; readonly rest: string; readonly isHeading: boolean };
+
+type ContinuesSentence = (number: string, rest: string) => boolean;
+
+/**
+ * 本文の行の「3.11.0 was released on 2024-10-17.」「3.11.0 を公開しました。」の番号は、文の主語や目的語で、節の番号ではない。
+ * 続きが文として終わり、しかも小文字の語で始まるか、言語パッケージが文の続き（日本語なら助詞）と読んだとき。
+ * 小文字の題（「3.1 overview」「4.2.1.  about:blank」）と見出しの行は章番号。
+ */
+export const numberInSentence = (numbered: NumberedText, continuesSentence?: ContinuesSentence): boolean =>
+  !numbered.isHeading &&
+  SENTENCE_END.test(numbered.rest) &&
+  (LOWERCASE_WORD.test(numbered.rest) || continuesSentence?.(numbered.number, numbered.rest) === true);

package/src/structure/unit-word.ts

@@ -0,0 +1,11 @@
+import type { StructureNode } from "../plugin.ts";
+
+/**
+ * 参照が単位の語（attrs.unitWord、日本語の「条」）で番号を名指していて、文書のどの条の番号にもその語が無い。
+ * 見出しに「1 目的」と番号を振った指針の「法第2条」は、指針の 2 ではなく、その語で条を数える別の文書（法律）の条。
+ * 単位の語を付けない言語・参照（英語の Section）は、ここでは決めない。
+ */
+export const namesAbsentUnit = (reference: StructureNode, articleLabels: readonly string[]): boolean => {
+  const unitWord = reference.attrs["unitWord"];
+  return typeof unitWord === "string" && unitWord !== "" && !articleLabels.some((label) => label.includes(unitWord));
+};

package/src/structure/wrapped-tail.ts

@@ -0,0 +1,22 @@
+import type { Mention } from "../plugin.ts";
+
+/**
+ * 参照を読む行と、その後ろにつないだ次の行。
+ *
+ * 72 桁で折り返す RFC は「Section 16.3.2\n   of [HTTP]」のように、参照と「どの文書の」を別の行に書く。行だけを読むと
+ * 自分の文書の 16.3.2 に見える。改行と字下げは読み手には空白一つなので、そうつないだ文字列を言語の読み手に渡す。
+ * 拾った参照は行の中にあるものだけを残す。次の行の参照は、次の行を読むときに拾う。位置は行の上のまま。
+ */
+export type WrappedLine = { readonly line: string; readonly text: string; readonly lineLength: number };
+
+/** 見出しは次の行へ続かない。見出しの行か、次の行が無い・空なら、行だけ。 */
+export const wrappedLine = (text: string, onHeading: boolean, next: string | undefined): WrappedLine => {
+  const tail = onHeading ? "" : (next?.trim() ?? "");
+  if (tail === "") return { line: text, text, lineLength: text.length };
+  const kept = text.trimEnd();
+  return { line: text, text: `${kept} ${tail}`, lineLength: kept.length };
+};
+
+/** 行の中で終わる参照だけ。つないだ次の行に入り込んだもの（「Sections 1,\n 2」の 2）は捨てる。 */
+export const onLine = (mentions: readonly Mention[], wrapped: WrappedLine): readonly Mention[] =>
+  mentions.filter((mention) => mention.end <= wrapped.lineLength);