chaffjs 0.18.0 → 0.19.0

package/src/detectors/ra-nuki.ts

@@ -0,0 +1,38 @@
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** 言語アダプタが、ら抜き言葉の一部の語に付ける印（lang-ja の PotentialRa=Dropped）。 */
+const isRaDropped = (token: Token): boolean => token.features?.["PotentialRa"] === "Dropped";
+
+/** 印の付いた語が続く並び（「食べ」「れる」）を一つにまとめた、文書の中の範囲。 */
+const markedRuns = (tokens: readonly Token[]): Span[] =>
+  tokens.reduce<Span[]>((runs, token, index) => {
+    if (!isRaDropped(token)) return runs;
+    const last = runs.at(-1);
+    const previous = tokens[index - 1];
+    if (last !== undefined && previous !== undefined && isRaDropped(previous)) return [...runs.slice(0, -1), { start: last.start, end: token.span.end }];
+    return [...runs, token.span];
+  }, []);
+
+export type RaDroppedWord = { readonly written: string; readonly offset: number };
+
+/** 文の中のら抜き言葉。鉤括弧や引用符で引いた言葉（話した言葉をそのまま引いたもの）は数えない。 */
+export const raDroppedIn = (sentence: Sentence): RaDroppedWord[] => {
+  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  return markedRuns(sentence.tokens ?? [])
+    .map((run) => ({ start: run.start - sentence.span.start, end: run.end - sentence.span.start }))
+    .filter((run) => !isWithinAny(quoted, run))
+    .map((run) => ({ written: sentence.text.slice(run.start, run.end), offset: sentence.span.start + run.start }));
+};
+
+export const raNuki: Detector = (doc): Finding[] =>
+  doc.sentences.flatMap((sentence) =>
+    raDroppedIn(sentence).map((word) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: word.written, offset: word.offset },
+    })),
+  );

package/src/detectors/requirement-modal.ts

@@ -0,0 +1,67 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, OptionValue, Sentence } from "../plugin.ts";
+import { entryCloses, entryIn, entryRanges, type TokenRange } from "./lexicon-match.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedIn } from "../quoted-span.ts";
+
+// The verbal forms a house rule does not use for a provision: JIS Z 8301:2019's すべきである and a closing できる, or the
+// Federal Plain Language Guidelines' "shall". Off until a team picks one; each choice reads one lexicon, which holds
+// the forms and what to write instead (instead_of). A language without that lexicon has nothing to check.
+
+/** The lexicons the rule's options turn on: requirement-modal-<standard>, and requirement-modal-must for shall: must. */
+export const modalLexiconNames = (settings: Readonly<Record<string, OptionValue>>): string[] => [
+  ...(typeof settings["standard"] === "string" && settings["standard"] !== "none" ? [`requirement-modal-${settings["standard"]}`] : []),
+  ...(settings["shall"] === "must" ? ["requirement-modal-must"] : []),
+];
+
+type Use = { readonly entry: LexiconEntry; readonly offset: number };
+
+const startOf = (sentence: Sentence, range: TokenRange | undefined): number =>
+  range === undefined ? sentence.span.start : (sentence.tokens?.[range.start]?.span.start ?? sentence.span.start);
+
+const spanOf = (sentence: Sentence, range: TokenRange): { start: number; end: number } => ({
+  start: startOf(sentence, range),
+  end: sentence.tokens?.[range.end - 1]?.span.end ?? sentence.span.end,
+});
+
+/** Where the words of the form are in the sentence: only the closing one for position: after, else every one. */
+const candidateRanges = (sentence: Sentence, entry: LexiconEntry): TokenRange[] => {
+  const ranges = entryRanges(sentence, entry);
+  if (entry.position !== "after") return ranges;
+  const closing = ranges.at(-1);
+  return entryCloses(sentence, entry) && closing !== undefined ? [closing] : [];
+};
+
+/** Whether the sentence has the form at all, read on its text: for a sentence the adapter gave no tokens. */
+const presentInText = (sentence: Sentence, entry: LexiconEntry): boolean =>
+  entry.position === "after" ? entryCloses(sentence, entry) : entryIn(sentence, entry);
+
+/**
+ * Where the sentence uses the form, or undefined. A form with position: after must close the sentence. Either must stand
+ * outside quotation marks: 'The key words "MUST" and "SHALL" …' and 禁止語は「べきである」。 mention a form, not use it.
+ */
+const useOf = (sentence: Sentence, entry: LexiconEntry): Use | undefined => {
+  if (sentence.tokens === undefined) return presentInText(sentence, entry) ? { entry, offset: sentence.span.start } : undefined;
+  const quoted = quotedIn(sentence, QUOTATION_MARKS);
+  const used = candidateRanges(sentence, entry).find((range) => !isWithinAny(quoted, spanOf(sentence, range)));
+  return used === undefined ? undefined : { entry, offset: startOf(sentence, used) };
+};
+
+const findingOf = (sentence: Sentence, use: Use): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { matched: use.entry.pattern, preferred: use.entry.instead_of ?? "", offset: use.offset },
+});
+
+/** Each form of the lexicons the sentence uses. */
+const formsIn = (sentence: Sentence, lexicon: Lexicon): Finding[] =>
+  lexicon.flatMap((entry) => {
+    const use = useOf(sentence, entry);
+    return use === undefined ? [] : [findingOf(sentence, use)];
+  });
+
+export const requirementModal: Detector = (doc, options): Finding[] => {
+  const lexicon = modalLexiconNames(options.settings ?? {}).flatMap((name) => doc.lexicons[name] ?? []);
+  return lexicon.length === 0 ? [] : doc.sentences.flatMap((sentence) => formsIn(sentence, lexicon));
+};

package/src/detectors/requirement-smell.ts

@@ -0,0 +1,52 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
+
+// Requirements smells (Femmer et al. 2017; Berry et al. 2003; ISO/IEC/IEEE 29148): a loophole, an open-ended list and
+// "and/or", in a sentence that states a requirement. What makes a sentence a requirement, and each smell's words, come
+// from the language's lexicons; this file knows neither language.
+
+/** Each smell: the lexicon of its words, and the finding's variant (the rule's messages). */
+const SMELLS = [
+  { lexicon: "requirement-loophole", variant: "loophole" },
+  { lexicon: "requirement-open-end", variant: "open-end" },
+  { lexicon: "requirement-either", variant: "either" },
+] as const;
+
+const MARKERS = "requirement-marker";
+/** Sentence ends that look like a marker and are not one (「…のこと。」 defines a term). The language may have none. */
+const NOT_MARKERS = "requirement-not-marker";
+
+/** A marker with position: after counts only at the end of the sentence (「…できること。」); any other, anywhere in it. */
+const isMarkedBy = (sentence: Sentence, entry: LexiconEntry): boolean => (entry.position === "after" ? entryCloses(sentence, entry) : entryIn(sentence, entry));
+
+export const isRequirement = (sentence: Sentence, markers: Lexicon, notMarkers: Lexicon): boolean =>
+  markers.some((entry) => isMarkedBy(sentence, entry)) && !notMarkers.some((entry) => isMarkedBy(sentence, entry));
+
+/** Where in the document the word starts: its first token, or the sentence when there are no tokens. */
+const offsetOf = (sentence: Sentence, entry: LexiconEntry): number => {
+  const range = entryRanges(sentence, entry)[0];
+  return range === undefined ? sentence.span.start : (sentence.tokens?.[range.start]?.span.start ?? sentence.span.start);
+};
+
+const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  variant,
+  values: { matched: entry.pattern, offset: offsetOf(sentence, entry) },
+});
+
+/** The first word of each smell in one requirement sentence: one finding per smell, not per word. */
+const smellsIn = (sentence: Sentence, lexicons: ProseDocument["lexicons"]): Finding[] =>
+  SMELLS.flatMap(({ lexicon, variant }) => {
+    const entry = (lexicons[lexicon] ?? []).find((candidate) => entryIn(sentence, candidate));
+    return entry === undefined ? [] : [findingOf(sentence, entry, variant)];
+  });
+
+export const requirementSmell: Detector = (doc): Finding[] => {
+  const markers = doc.lexicons[MARKERS] ?? [];
+  const notMarkers = doc.lexicons[NOT_MARKERS] ?? [];
+  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(sentence, doc.lexicons));
+};

package/src/detectors/space-before-punctuation.ts

@@ -0,0 +1,32 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/**
+ * 字で終わる語（閉じ括弧や閉じ引用符が一つ付いてもよい）のすぐ後ろの半角空白一つと、それに続く句読点（"word ."、"(word) ,"）。句読点の後ろは空白か行の終わりか閉じの記号で、
+ * ".NET" や ".5" のように次の語の頭の点は数えない。数の後ろ（式の "[ 1 , N ]"）と、"Note : " "ISSN : " のように欄の印として空けるコロンは見ない。
+ */
+const SPACED_MARK = /(?<=\p{L}[)\]}"'”’]?) (?=[.,;?!](?:[\s)\]"'”’]|$))/gu;
+
+/** 空白で区切った点の並び（". . ."）。省略の印と、目次の点線。 */
+const SPACED_DOTS = /^\. ?\./u;
+
+const DOTS_REACH = 3;
+
+const isSpacedEllipsis = (text: string, space: number): boolean => SPACED_DOTS.test(text.slice(space + 1, space + 1 + DOTS_REACH));
+
+/**
+ * 本文（prose）の中の、句読点の前の空白の位置。prose はコード・URL・強調の印を空白で覆うので、覆ってできた空白（"*word* ." の "*"）は
+ * 書き手が打った空白ではない。source の同じ位置も空白のときだけ数える。
+ */
+export const spacesBeforePunctuation = (prose: string, source: string): number[] =>
+  [...prose.matchAll(SPACED_MARK)].map((match) => match.index).filter((space) => source.charAt(space) === " " && !isSpacedEllipsis(prose, space));
+
+export const spaceBeforePunctuation: Detector = (doc): Finding[] =>
+  spacesBeforePunctuation(doc.prose ?? doc.source, doc.source).map((space) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, space, space + 2),
+    values: { mark: doc.source.charAt(space + 1), offset: space },
+  }));

package/src/detectors/spelling-variety.ts

@@ -0,0 +1,81 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { minorityWithin } from "../orthography.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/**
+ * 綴りの組の語彙表の名前の頭。組（spelling-variant、spelling-ize）ごとに比べる。組を分けるのは、両方の書き方が一つの
+ * 書き方の決まりの中にあるから（Oxford の綴りは colour と organize を一緒に使う）。
+ */
+const SPELLING_LISTS = "spelling-";
+
+type Spelling = { readonly family: string; readonly pattern: boolean; readonly other: string };
+
+/** 語（小文字）から、その語がどの組のどちらの綴りか。 */
+const spellingsOf = (lexicons: ProseDocument["lexicons"]): ReadonlyMap<string, Spelling> =>
+  new Map(
+    Object.entries(lexicons)
+      .filter(([id]) => id.startsWith(SPELLING_LISTS))
+      .flatMap(([family, entries]: [string, Lexicon]) =>
+        entries.flatMap((entry): [string, Spelling][] =>
+          entry.instead_of === undefined
+            ? []
+            : [
+                [entry.pattern.toLowerCase(), { family, pattern: true, other: entry.instead_of }],
+                [entry.instead_of.toLowerCase(), { family, pattern: false, other: entry.pattern }],
+              ],
+        ),
+      ),
+  );
+
+const WORD = /\p{L}+/gu;
+
+/** 語の直前の開きの引用符。引いた語（use ‘organise’ not ‘organize’）は書き手の綴りではなく、話題にした語。 */
+const OPENING_QUOTE = /[‘'"“]/u;
+const CAPITAL = /^\p{Lu}/u;
+
+/** 大文字で始まる次の語。文の頭でも、大文字の語が続けば名前（Labor Day、Centre Court）。 */
+const CAPITALISED_NEXT = /^[ \t]+\p{Lu}/u;
+
+export type SpelledWord = { readonly written: string; readonly offset: number; readonly spelling: Spelling };
+
+/**
+ * 文の中の、組に載った綴りの語。文の頭でないのに大文字で始まる語と、大文字の語が続く語（Labor Day、World Health Organization）は名前で、名前の綴りは
+ * 変えられないので数えない。引用符で引いたものの中も、引いた元の綴りなので数えない。offset は文書の中の位置。
+ */
+export const spelledWordsIn = (sentence: Sentence, spellings: ReadonlyMap<string, Spelling>): SpelledWord[] => {
+  const quoted: readonly Span[] = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const first = sentence.text.search(/\p{L}/u);
+  return [...sentence.text.matchAll(WORD)].flatMap((match) => {
+    const spelling = spellings.get(match[0].toLowerCase());
+    const named = CAPITAL.test(match[0]) && (match.index !== first || CAPITALISED_NEXT.test(sentence.text.slice(match.index + match[0].length)));
+    const inQuote =
+      isWithinAny(quoted, { start: match.index, end: match.index + match[0].length }) || OPENING_QUOTE.test(sentence.text.charAt(match.index - 1));
+    return spelling === undefined || named || inQuote ? [] : [{ written: match[0], offset: sentence.span.start + match.index, spelling }];
+  });
+};
+
+type Located = { readonly sentence: Sentence; readonly word: SpelledWord };
+
+const findingOf = ({ sentence, word }: Located, count: number, of: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { matched: word.written, other: word.spelling.other, count, of, offset: word.offset },
+});
+
+/**
+ * イギリスとアメリカの綴り（colour と color、centre と center）が一つの文書で混ざっているか。組ごとに、文書の中で少ないほうを
+ * 指摘する。どちらが正しいかは決めない。少ないほうが組の limit パーセントを超えるなら、使い分けと見て言わない。
+ */
+export const spellingVariety: Detector = (doc, options): Finding[] => {
+  const spellings = spellingsOf(doc.lexicons);
+  const located: Located[] = doc.sentences.flatMap((sentence) => spelledWordsIn(sentence, spellings).map((word) => ({ sentence, word })));
+  const families = [...new Set(located.map(({ word }) => word.spelling.family))];
+  return families.flatMap((family) => {
+    const ofFamily = located.filter(({ word }) => word.spelling.family === family);
+    const odd = minorityWithin(ofFamily, ({ word }) => word.spelling.pattern, options.limit);
+    return odd.map((entry) => findingOf(entry, odd.length, ofFamily.length));
+  });
+};

package/src/detectors/structure-tree.ts

@@ -4,7 +4,7 @@ import { numberingBreaks } from "../structure/numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
-import { reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 
 const QUOTE_LENGTH = 80;
@@ -106,6 +106,8 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
+  frames: (doc.lexicons["range-frame"] ?? []).flatMap((entry) => rangeFrameOf(entry.pattern) ?? []),
+  changes: (doc.lexicons["date-change-word"] ?? []).map((entry) => entry.pattern),
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */

package/src/detectors/structure.ts

@@ -1,5 +1,5 @@
 import { charLength, lengthOf } from "../measure.ts";
-import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
+import type { BulletList, Detector, DetectorOptions, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
 import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { preambleParagraphs } from "../preamble-paragraphs.ts";
@@ -25,6 +25,18 @@ const PERCENT = 100;
 
 const asPercent = (value: number): number => Math.round(value * PERCENT);
 
+/**
+ * 揃いすぎを測るのに要る、値の数の下限（rule の options）。値が少ないと変動係数は偶然で小さく出る。
+ * 人の書いた記事では、指摘が節や段落の少ない文書に偏っていた。
+ */
+const minimumCount = (options: DetectorOptions, name: string, fallback: number): number => {
+  const value = options.settings?.[name];
+  return typeof value === "number" ? value : fallback;
+};
+
+const DEFAULT_MIN_SECTIONS = 5;
+const DEFAULT_MIN_PARAGRAPHS = 6;
+
 const uniformity = (doc: ProseDocument, values: readonly number[], span: { start: number }, limit: number, rule: string): Finding[] => {
   const cv = coefficientOfVariation(values);
   if (cv === undefined || asPercent(cv) >= limit) return [];
@@ -65,7 +77,8 @@ const charsOf = (paragraph: Paragraph): number => paragraph.sentences.reduce((su
 export const paragraphVariance: Detector = (doc, options): Finding[] => {
   const lengths = doc.paragraphs.map(charsOf).filter((length) => length > 0);
   const first = doc.paragraphs[0];
-  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
+  if (first === undefined || lengths.length < minimumCount(options, "min_paragraphs", DEFAULT_MIN_PARAGRAPHS)) return [];
+  return uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
 };
 
 const sectionChars = (section: Section): number => section.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
@@ -74,7 +87,8 @@ const sectionChars = (section: Section): number => section.sentences.reduce((sum
 export const sectionUniformity: Detector = (doc, options): Finding[] => {
   const lengths = doc.sections.map(sectionChars).filter((length) => length > 0);
   const first = doc.sections[0];
-  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
+  if (first === undefined || lengths.length < minimumCount(options, "min_sections", DEFAULT_MIN_SECTIONS)) return [];
+  return uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
 };
 
 /**

package/src/detectors/superlative-comparison.ts

@@ -0,0 +1,47 @@
+import type { Lexicon, LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn, quotedSpans, QUOTATION_MARKS } from "../quoted-span.ts";
+import { entryEndsAt, entryIn, type TokenRange } from "./lexicon-match.ts";
+
+/**
+ * 比べる相手を言う語。語彙表の position で分ける。
+ * position の無い語（より・のほうが・than）は、文のどこにあっても比べる相手を言っている。
+ * position: before の語（との）は、最上級のすぐ前にあるときだけ。「SES との最大の分岐点」は相手を言うが、
+ * 「チームとの会議で最高の成果」の「との」は最上級と関わらない。
+ */
+export type ComparisonMarkers = { readonly anywhere: Lexicon; readonly before: Lexicon };
+
+export const comparisonMarkersOf = (lexicon: Lexicon): ComparisonMarkers => ({
+  anywhere: lexicon.filter((entry) => entry.position === undefined),
+  before: lexicon.filter((entry) => entry.position === "before"),
+});
+
+/** 最上級のすぐ前で、比べる相手を受ける語が終わっているか。 */
+export const counterpartBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
+  markers.some((entry) => entryEndsAt(tokens, entry, range.start));
+
+const spanOf = (tokens: readonly Token[], range: TokenRange): Span | undefined => {
+  const first = tokens[range.start];
+  const last = tokens[range.end - 1];
+  return first === undefined || last === undefined ? undefined : { start: first.span.start, end: last.span.end };
+};
+
+/** 引用符や鉤括弧の中の最上級。人の言葉や題名を引いたもので、書き手が比べずに言い切ったものではない。 */
+export const quotedRange = (sentence: Sentence, range: TokenRange): boolean => {
+  const span = spanOf(sentence.tokens ?? [], range);
+  return span !== undefined && isWithinAny(quotedIn(sentence, QUOTATION_MARKS), span);
+};
+
+/** 引いた言葉の中身を空白にした文。位置は変えない。 */
+const unquotedText = (text: string): string => {
+  const quoted = quotedSpans(text, QUOTATION_MARKS);
+  return text
+    .split("")
+    .map((char, at) => (quoted.some((span) => at >= span.start && at < span.end) ? " " : char))
+    .join("");
+};
+
+/** 語が、引いた言葉の中にしか無いか。字で照らすので、品詞の無い文でも言える。 */
+export const onlyQuoted = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const wrapped = sentence.wrapBreaks === undefined ? {} : { wrapBreaks: sentence.wrapBreaks };
+  return !entryIn({ span: sentence.span, text: unquotedText(sentence.text), ...wrapped }, entry);
+};

package/src/detectors/url-run-on.ts

@@ -10,6 +10,12 @@ const BARE_URL = /https?:\/\/[!-~]+/gu;
  */
 const RUNS_ON = /[^\s\p{Cf}]/u;
 
+/** index から始まる一字（サロゲートの対は一字）。末尾より後ろは空。 */
+const characterAt = (text: string, index: number): string => {
+  const point = text.codePointAt(index);
+  return point === undefined ? "" : String.fromCodePoint(point);
+};
+
 export type RunOnUrl = { readonly url: Span; readonly next: string };
 
 /** 字のまま見える範囲（texts）の中の、すぐ後ろに空白を置かずに日本語や全角の記号が続く URL。 */
@@ -18,7 +24,7 @@ export const runOnUrls = (source: string, texts: readonly Span[]): RunOnUrl[] =>
     const written = source.slice(text.start, text.end);
     return [...written.matchAll(BARE_URL)].flatMap((match) => {
       const end = match.index + match[0].length;
-      const next = [...written.slice(end, end + 2)][0] ?? "";
+      const next = characterAt(written, end);
       return RUNS_ON.test(next) ? [{ url: { start: text.start + match.index, end: text.start + end }, next }] : [];
     });
   });

package/src/detectors/vague-figure-pointer.ts

@@ -0,0 +1,58 @@
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
+import { FIGURE_NUMBER, labelledKindsIn } from "../figure-references.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { labelWordsOf } from "./dangling-figure.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { numbersClauses } from "../structure/numbered-clauses.ts";
+
+// A figure or a table pointed at by where it is (上記の図, the table below) in a document that numbers that kind and
+// could name it (図3, Table 2), and a clause (以下の箇条, the clause below) in a document that numbers its clauses.
+// JIS Z 8301:2019 10.6. The phrases and the kind each points at come from the lexicons.
+
+export type VaguePointer = { readonly offset: number; readonly written: string; readonly kind: string };
+
+/** A phrase inside a longer word (向上の図, 上の図表) is not one. */
+const EDGE = "[\\p{Script=Han}\\p{Script=Katakana}A-Za-z0-9０-９]";
+
+/** Matched in any case (The figure below). */
+const pointerPattern = (pattern: string): RegExp => new RegExp(`(?<!${EDGE})${escapeRegExp(pattern)}(?!${EDGE})`, "giu");
+
+/** A pointer followed by a number names the figure (上の図 １, the figure below 2, the table above IV): the numbers figure labels take. */
+const NUMBERED = new RegExp(`^${FIGURE_NUMBER}`, "u");
+/** Enough characters after a pointer to hold a figure's number (第十二, 3.2.1). */
+const NUMBER_LOOKAHEAD = 16;
+
+/** Pure: every pointer in the prose that points at a kind the document labels. */
+export const vaguePointers = (prose: string, pointers: Lexicon, labelledKinds: ReadonlySet<string>): VaguePointer[] =>
+  pointers
+    .flatMap((entry) => {
+      const kind = entry.instead_of;
+      if (kind === undefined || !labelledKinds.has(kind)) return [];
+      return [...prose.matchAll(pointerPattern(entry.pattern))]
+        .filter((match) => !NUMBERED.test(prose.slice(match.index + match[0].length, match.index + match[0].length + NUMBER_LOOKAHEAD)))
+        .map((match) => ({ offset: match.index, written: match[0], kind }));
+    })
+    .toSorted((left, right) => left.offset - right.offset);
+
+const kindsOf = (pointers: Lexicon): Set<string> => new Set(pointers.flatMap((entry) => entry.instead_of ?? []));
+
+/** The clause kinds to check. The tree is built only when a clause pointer is written, so other documents do not pay for it. */
+const clauseKindsIn = (doc: ProseDocument, prose: string, pointers: Lexicon): string[] => {
+  const kinds = kindsOf(pointers);
+  if (vaguePointers(prose, pointers, kinds).length === 0) return [];
+  return doc.structure !== undefined && numbersClauses(doc.structure) ? [...kinds] : [];
+};
+
+export const vagueFigurePointer: Detector = (doc): Finding[] => {
+  const prose = doc.prose ?? doc.source;
+  const clausePointers = doc.lexicons["vague-clause-pointer"] ?? [];
+  const kinds = new Set([...labelledKindsIn(doc.source, labelWordsOf(doc)), ...clauseKindsIn(doc, prose, clausePointers)]);
+  return vaguePointers(prose, [...(doc.lexicons["vague-figure-pointer"] ?? []), ...clausePointers], kinds).map((pointer) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, pointer.offset),
+    values: { matched: pointer.written, kind: pointer.kind, offset: pointer.offset },
+  }));
+};

package/src/detectors/word-list.ts

@@ -1,2 +1,7 @@
+const separatorOf = (language: string): string => (language === "ja" ? "、" : ", ");
+
 /** 語の並べ方は文書の言語に合わせる。日本語は「、」、ほかは ", "。英語の画面に「Risks、Costs」と出さない。 */
-export const joinWords = (words: readonly string[], language: string): string => words.join(language === "ja" ? "、" : ", ");
+export const joinWords = (words: readonly string[], language: string): string => words.join(separatorOf(language));
+
+/** joinWords で並べた語を、元の語に戻す。 */
+export const splitWords = (joined: string, language: string): string[] => (joined === "" ? [] : joined.split(separatorOf(language)));