chaffjs 0.17.0 → 0.19.0

package/src/detectors/cited-title.ts

@@ -0,0 +1,96 @@
+import type { Token } from "../plugin.ts";
+import { MINOR_WORDS } from "./heading-case.ts";
+import { columnOf, firstIn, lastIn, type Column } from "./token-column.ts";
+
+// 引用した題名（誌名・論文名・書名）。題名の中の読点は題名を付けた人のもので、書き手が並べかたを選んだものではない。
+
+const isCapitalised = (token: Token): boolean => /^\p{Lu}/u.test(token.surface);
+
+/** 題名の中でつなぐ記号。ハイフン（Low-Inflation）と、副題の前のコロン（Maximum Employment: A Shortfalls Approach）。 */
+const TITLE_JOINERS: ReadonlySet<string> = new Set(["-", ":"]);
+
+/** 題名の中の語。大文字で始まる語と、Title Case でも小文字のままの語（of, and, a）と、つなぐ記号。 */
+const isTitleWord = (token: Token): boolean => isCapitalised(token) || MINOR_WORDS.has(token.surface) || TITLE_JOINERS.has(token.surface);
+
+/** 題名の中の区切り。左は読点もまたぐ（Journal of Money, Credit）。 */
+const inLeftRun = (token: Token): boolean => isTitleWord(token) || token.surface === ",";
+
+/** 2 つの語の間が空白だけか。覆った強調の印（*Journal）や記号を挟めば、題名の語の続きはそこで切れる。 */
+const adjoins = (source: string, left: Token | undefined, right: Token | undefined): boolean =>
+  left === undefined || right === undefined || source.slice(left.span.end, right.span.start).trim() === "";
+
+const LIST_CONJUNCTIONS: ReadonlySet<string> = new Set(["and", "or"]);
+
+const isPhraseWord = (token: Token): boolean => (isCapitalised(token) || MINOR_WORDS.has(token.surface)) && !LIST_CONJUNCTIONS.has(token.surface);
+
+/**
+ * 題名の語の続きの切れ目。左の続きは、題名の語でも読点でもない語か、次の語との間に空白以外を挟む語で切れる。
+ * 右の続きは、題名の語でない語か、前の語との間に空白以外を挟む語で切れる。
+ */
+type Runs = { readonly leftBreak: Column; readonly rightBreak: Column; readonly capital: Column; readonly phrasePair: Column };
+
+const runsOf = (tokens: readonly Token[], source: string): Runs => ({
+  leftBreak: columnOf(tokens, (token, index) => !inLeftRun(token) || !adjoins(source, token, tokens[index + 1])),
+  rightBreak: columnOf(tokens, (token, index) => !isTitleWord(token) || !adjoins(source, tokens[index - 1], token)),
+  capital: columnOf(tokens, isCapitalised),
+  phrasePair: columnOf(tokens, (token, index) => index > 0 && isPhraseWord(token) && isPhraseWord(tokens[index - 1] ?? token)),
+});
+
+/**
+ * and / or の左の、題名の語の続きの頭。最初の大文字の語から。小文字の語から始めると、引用符の中の並び（‘the UK, France and
+ * Spain’）や、論文名のあとの編者の並び（," in Heather Boushey, Ryan Nunn, and Jay Shambaugh, eds.）まで題名と読む。
+ */
+const leftStart = (runs: Runs, at: number): number | undefined => {
+  const stop = lastIn(runs.leftBreak, { start: 0, end: at });
+  const start = firstIn(runs.capital, { start: stop + 1, end: at });
+  return start === -1 ? undefined : start;
+};
+
+/** and / or の右の、題名の語の続きの最後の大文字の語。 */
+const rightEnd = (runs: Runs, at: number, length: number): number | undefined => {
+  const stop = firstIn(runs.rightBreak, { start: at + 1, end: length });
+  const last = lastIn(runs.capital, { start: at + 1, end: stop === -1 ? length : stop });
+  return last === -1 ? undefined : last;
+};
+
+/** 印を探す幅。いちばん長い印（***）と、読点・引用符・空白が収まる。 */
+const MARK_REACH = 8;
+
+/** 題名の最初の語にくっついた開きの印（“ ‘ " ' * _）。 */
+const OPENING = /(?:["'“‘]|\*{1,3}|_{1,3})$/u;
+/** 題名の直後の閉じの印。句読点を挟んでよい（Employment,”）。印の後ろが語なら、語の中の字（TO_CHAR、Madrid’s）。 */
+const CLOSING = /^[,.;:!?]?(?:["'”’]|\*{1,3}|_{1,3})(?![\p{L}\p{N}])/u;
+/** 引用した論文名のあとの読点と閉じる引用符。そのあとの題名は誌名（"Three Lessons," Journal of Money, Credit and Banking）。 */
+const AFTER_QUOTED_TITLE = /,\s*["'”’]\s*$/u;
+/** 誌名のあとは、巻号や頁へ続く読点か文の終わり。述語が続けば（“Done,” Smith, Jones and Brown argued）主語の並び。 */
+const VENUE_END = /^\s*(?:[,;.]|$)/u;
+
+/**
+ * 語の続きに、2 語以上の句があるか（Journal of Money、Their Nature、The Update）。1 語ずつの名前の並び
+ * （‘Paris, Rome and Madrid’）は、引用符の中でも書き手が並べたもの。
+ */
+const holdsPhrase = (runs: Runs, start: number, end: number): boolean => firstIn(runs.phrasePair, { start: start + 1, end: end + 1 }) !== -1;
+
+/**
+ * 文の and / or が、引用した題名の中にあるか。and / or の両隣が Title Case の語の続きで、2 語以上の句を含み、その続きが
+ * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）とき。
+ * 本文の固有名詞の並び（Login.gov, TTS Engineering and USAi）や著者の並びは囲まれていないので、題名と読まない。
+ * 文を一度だけ読み、どの位置の問いにも続きを読み直さずに答える。
+ */
+export const citedTitles = (tokens: readonly Token[], source: string): ((at: number) => boolean) => {
+  const runs = runsOf(tokens, source);
+  return (at) => {
+    const start = leftStart(runs, at);
+    const end = rightEnd(runs, at, tokens.length);
+    const first = start === undefined ? undefined : tokens[start];
+    const last = end === undefined ? undefined : tokens[end];
+    if (start === undefined || end === undefined || first === undefined || last === undefined) return false;
+    if (!holdsPhrase(runs, start, end)) return false;
+    const before = source.slice(Math.max(0, first.span.start - MARK_REACH), first.span.start);
+    const after = source.slice(last.span.end, last.span.end + MARK_REACH);
+    return (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+  };
+};
+
+/** at の and / or が、引用した題名の中にあるか。 */
+export const inCitedTitle = (tokens: readonly Token[], at: number, source: string): boolean => citedTitles(tokens, source)(at);

package/src/detectors/concrete-evidence.ts

@@ -1,4 +1,5 @@
 import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+import { preOrder } from "../tree-walk.ts";
 
 /**
  * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
@@ -27,5 +28,5 @@ export const startsWithin = (section: Span, spans: readonly Span[]): boolean =>
 /** 構造の木が読んだ参照（第3条・Section VI）・数量・日付。どれも読み手が確かめに行ける具体物。 */
 const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "date"]);
 
-export const evidenceSpans = (node: StructureNode | undefined): Span[] =>
-  node === undefined ? [] : [...(EVIDENCE.has(node.kind) ? [node.span] : []), ...node.children.flatMap((child) => evidenceSpans(child))];
+export const evidenceSpans = (root: StructureNode | undefined): Span[] =>
+  root === undefined ? [] : preOrder(root).flatMap((node) => (EVIDENCE.has(node.kind) ? [node.span] : []));

package/src/detectors/contrast-frame.ts

@@ -0,0 +1,54 @@
+import type { Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { comparableText, comparableWords, entryIn, entryOpens, entryRanges } from "./lexicon-match.ts";
+
+/**
+ * 対比の枠の語。frames は 1 つで枠になる語（not only、だけでなく）。
+ * leads は打ち消し（it's not、単なる）で、turns（it's、but、ではなく）が後ろに来たときだけ枠になる。同じ文の後ろか、次の文の頭。
+ * 打ち消しの頭に立つ返しの語（It's not ready. It's not tested. の 2 つ目の It's）は返しではなく、次の打ち消し。
+ */
+export type ContrastWords = { readonly frames: Lexicon; readonly leads: Lexicon; readonly turns: Lexicon };
+
+const lowered = (entry: LexiconEntry): string => comparableWords(entry.pattern);
+
+type Range = { readonly start: number; readonly end: number };
+
+/** 返しの語が、それより長い打ち消しの頭にあるか（It's not の It's）。同じ長さなら返しのまま（ではなく は打ち消しでも返しでもある）。 */
+const opensLongerLead = (found: Range, leads: readonly Range[]): boolean => leads.some((lead) => lead.start === found.start && lead.end > found.end);
+
+const answersAfter = (leadRange: Range, turns: readonly Range[], leads: readonly Range[]): boolean =>
+  turns.some((found) => found.start >= leadRange.end && !opensLongerLead(found, leads));
+
+/** 文字列の中で word が現れる範囲、左から順に。 */
+const rangesOf = (text: string, word: string): Range[] =>
+  [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => ({ start: match.index, end: match.index + word.length }));
+
+/** 品詞が無ければ位置を語で言えないので、空白をまとめた文字列の位置で比べる。 */
+const textTurnAfter = (sentence: Sentence, lead: LexiconEntry, words: ContrastWords): boolean => {
+  const text = comparableText(sentence);
+  const leads = words.leads.flatMap((entry) => rangesOf(text, lowered(entry)));
+  const turns = words.turns.flatMap((entry) => rangesOf(text, lowered(entry)));
+  return rangesOf(text, lowered(lead)).some((range) => answersAfter(range, turns, leads));
+};
+
+/** 打ち消しの語より後ろに、返しの語があるか。打ち消しそのもの（it's not の it's）と、次の打ち消しの頭は返しに数えない。 */
+const turnAfter = (sentence: Sentence, lead: LexiconEntry, words: ContrastWords): boolean => {
+  if (sentence.tokens === undefined || lead.tokens === undefined) return textTurnAfter(sentence, lead, words);
+  const leads = words.leads.flatMap((entry) => entryRanges(sentence, entry));
+  const turns = words.turns.flatMap((entry) => entryRanges(sentence, entry));
+  return entryRanges(sentence, lead).some((range) => answersAfter(range, turns, leads));
+};
+
+/** 次の文が返しの語で始まり、それ自体が打ち消しで始まっていないか。 */
+const nextTurns = (next: Sentence | undefined, words: ContrastWords): boolean =>
+  next !== undefined && words.turns.some((turn) => entryOpens(next, turn)) && !words.leads.some((lead) => entryOpens(next, lead));
+
+const answered = (sentence: Sentence, next: Sentence | undefined, words: ContrastWords): boolean =>
+  words.leads.some((lead) => entryIn(sentence, lead) && (turnAfter(sentence, lead, words) || nextTurns(next, words)));
+
+/**
+ * 対比の枠で書いた文。「X ではなく Y」「It's not X. It's Y.」の形で、打ち消した側の文を返す。
+ * 2 文にまたがる枠も 1 つと数える。返しの文は数えない。
+ */
+export const contrastSentences = (sentences: readonly Sentence[], words: ContrastWords): Sentence[] =>
+  sentences.filter((sentence, index) => words.frames.some((frame) => entryIn(sentence, frame)) || answered(sentence, sentences[index + 1], words));

package/src/detectors/custom.ts

@@ -0,0 +1,89 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import { occurrencesOutside } from "../orthography.ts";
+import { tokenRuns } from "../custom/token-pattern.ts";
+import { joinedView, type JoinedView } from "../joined-view.ts";
+import { boundedMatches } from "../custom/bounded-match.ts";
+
+// The detectors behind a team's custom_rules. Each reports every place it finds, at the rule's level; the spec comes from
+// the rule (DetectorOptions.custom). Positions are the document's, like every other finding.
+
+type Hit = { readonly sentence: Sentence; readonly offset: number; readonly matched: string; readonly preferred: string };
+
+const findingOf = (hit: Hit): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, preferred: hit.preferred, offset: hit.sentence.span.start + hit.offset },
+});
+
+/**
+ * The sentence with the line breaks that fall inside a word taken out (「関\nする」 reads 「関する」), so words and patterns
+ * are found as the reader reads them. Positions found in it go back to the sentence's own.
+ */
+const readAsWritten = (sentence: Sentence): JoinedView =>
+  joinedView(
+    sentence.text,
+    (sentence.wrapBreaks ?? []).map((span) => ({ start: span.start - sentence.span.start, end: span.end - sentence.span.start })),
+  );
+
+/** A match at [start, end) of the joined text, as a hit at the sentence's own position. */
+const hitAt = (sentence: Sentence, view: JoinedView, start: number, end: number, preferred: string): Hit => ({
+  sentence,
+  offset: view.toSource({ start, end }).start,
+  matched: view.text.slice(start, end),
+  preferred,
+});
+
+/** source[start, end) with the line breaks inside words taken out: the text of a run of tokens as the reader reads it. */
+const withoutBreaks = (source: string, start: number, end: number, breaks: readonly Span[]): string =>
+  breaks
+    .filter((span) => span.start >= start && span.end <= end)
+    .toReversed()
+    .reduce((text, span) => `${text.slice(0, span.start - start)}${text.slice(span.end - start)}`, source.slice(start, end));
+
+/** words: each spelling to avoid, outside the spelling to use (「ユーザ」 inside 「ユーザー」 is not reported). */
+export const customWords: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "words") return [];
+  return doc.sentences.flatMap((sentence) => {
+    const view = readAsWritten(sentence);
+    return spec.words.flatMap((pair) =>
+      occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => findingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
+    );
+  });
+};
+
+/** pattern: each match of the team's regular expression in a sentence. Checked when chaff.yaml was read, and run with a time limit. */
+export const customPattern: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "pattern") return [];
+  const views = doc.sentences.map(readAsWritten);
+  const matches = boundedMatches(
+    spec.pattern,
+    spec.flags,
+    views.map((view) => view.text),
+  );
+  return doc.sentences.flatMap((sentence, at) => {
+    const view = views[at];
+    if (view === undefined) return [];
+    return (matches[at] ?? []).map((match) => findingOf(hitAt(sentence, view, match.index, match.index + match.text.length, "")));
+  });
+};
+
+/** tokens: each run of tokens that meets the conditions in order, quoted from its first token to its last, line breaks inside words taken out. */
+export const customTokens: Detector = (doc, options): Finding[] => {
+  const spec = options.custom;
+  if (spec?.type !== "tokens") return [];
+  return doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokenRuns(tokens, spec.tokens).flatMap(([first, last]) => {
+      const [start, end] = [tokens[first]?.span.start, tokens[last]?.span.end];
+      if (start === undefined || end === undefined) return [];
+      return [
+        findingOf({ sentence, offset: start - sentence.span.start, matched: withoutBreaks(doc.source, start, end, sentence.wrapBreaks ?? []), preferred: "" }),
+      ];
+    });
+  });
+};

package/src/detectors/dangling-figure.ts

@@ -0,0 +1,26 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { danglingFigures, type Citations, type LabelWords } from "../figure-references.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** The language's words for figures, tables and appendices, and for a number that points elsewhere or counts. */
+export const labelWordsOf = (doc: ProseDocument): LabelWords => ({
+  labels: (doc.lexicons["figure-label"] ?? []).map((entry) => ({ word: entry.pattern, kind: entry.instead_of ?? entry.pattern })),
+  elsewhere: patternsOf(doc, "figure-elsewhere"),
+  counters: patternsOf(doc, "count-counter"),
+});
+
+const citationsOf = (doc: ProseDocument): Citations | undefined =>
+  doc.namedDocument === undefined ? undefined : { namedDocument: doc.namedDocument, sentences: doc.sentences.map((sentence) => sentence.span) };
+
+/** 本文が指す図・表・付録の番号が、キャプションにも見出しにも無い。他の文書の名前の後ろに書いた番号は、その文書の図。 */
+export const danglingFigure: Detector = (doc): Finding[] =>
+  danglingFigures(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links, citationsOf(doc)).map((dangling) => ({
+    rule: "dangling-figure-reference",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, dangling.offset),
+    values: { label: dangling.label, offset: dangling.offset },
+  }));

package/src/detectors/definition-use.ts

@@ -0,0 +1,41 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText } from "../structure/definition-use.ts";
+import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+
+const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<string, string | number>>): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+});
+
+/** 定義したのに、定義の外で一度も使っていない語。 */
+export const unusedDefinition: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc)).map((defined) => findingAt(doc, defined.span.start, { term: defined.term }));
+
+/** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
+export const useBeforeDefinition: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc)).map((use) => findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }));
+
+/** 同じ略語を、文書の中で二通りに展開している所。 */
+export const acronymExpansionConflict: Detector = (doc): Finding[] => {
+  const lines = linesOf(doc.source);
+  return expansionConflicts(bodyOf(doc).flatMap(expansionsIn)).map(({ expansion, first }) =>
+    findingAt(doc, expansion.offset, {
+      acronym: expansion.acronym,
+      name: expansion.name,
+      first: first.name,
+      firstLine: lineNumberAt(lines, first.offset) ?? 0,
+    }),
+  );
+};

package/src/detectors/doubled-punctuation.ts

@@ -0,0 +1,52 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/**
+ * 句読点が二つ並んだところ（「。。」「、。」「,,」「..」）。打ち直しで残った印。
+ * 同じ印を三つ以上並べたもの（「...」「。。。」）は、わざと伸ばした書き方なので数えない。その後ろに一つだけ付けた印（「...。」）も数えない。
+ * コロンは「::」（C++ の名前、IPv6）があるので見ない。
+ */
+const PUNCTUATION_RUN = /[、。，．,.;；]{2,}/gu;
+
+/** 略語の点の後ろの読点やセミコロン（e.g.,、Inc.,、etc.;）。 */
+const AFTER_ABBREVIATION = /^\.[,;]$/u;
+
+const WORD = /[\p{L}\p{N}]/u;
+
+/** 「..」の前後が字か数字か「/」なら、範囲や道のり（1..10、a..b、../）で、書き損じではない。 */
+const JOINED = /[\p{L}\p{N}/]/u;
+
+const isDrawnOut = (run: string): boolean => run.length >= 3 && [...run].every((mark) => mark === run.charAt(0));
+
+/** 伸ばした印（「...」「、、、」）は三点リーダーの代わりで、すぐ後ろの一つの印（「...。」「、、、。」）は文を閉じる印。 */
+const isDrawnOutThenClosed = (run: string): boolean => isDrawnOut(run.slice(0, -1));
+
+const isJoinedDots = (text: string, start: number, run: string): boolean =>
+  run === ".." && (JOINED.test(text.charAt(start + run.length)) || text.charAt(start - 1) === "/");
+
+export type DoubledMarks = { readonly start: number; readonly run: string };
+
+/** 並びの終わりの点が次の語の頭（「、.NET」「。.well-known」）なら、その点は語のうち。 */
+const withoutWordDot = (text: string, found: DoubledMarks): DoubledMarks =>
+  found.run.endsWith(".") && !isDrawnOut(found.run) && found.run !== ".." && WORD.test(text.charAt(found.start + found.run.length))
+    ? { start: found.start, run: found.run.slice(0, -1) }
+    : found;
+
+const isSlip = (text: string, { start, run }: DoubledMarks): boolean =>
+  run.length >= 2 && !isDrawnOut(run) && !isDrawnOutThenClosed(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
+
+/** text の中の、句読点が重なった並び（位置と並び）。 */
+export const doubledMarks = (text: string): DoubledMarks[] =>
+  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found));
+
+export const doubledPunctuation: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return doubledMarks(text).map(({ start, run }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, start, start + run.length),
+    values: { marks: run, offset: start },
+  }));
+};

package/src/detectors/doubled-word.ts

@@ -90,7 +90,18 @@ export const doubledAt = (source: string, first: Token, second: Token, spaced: b
 export const isNameBefore = (first: Token, second: Token, opensSentence: boolean): boolean =>
   !opensSentence && !isDeterminer(first) && UPPER_START.test(first.surface) && LOWER_START.test(second.surface);
 
-const opensSentence = (tokens: readonly Token[], at: number): boolean => !tokens.slice(0, at).some((token) => LETTER.test(token.surface));
+/** 大文字 1 字の語。 */
+const SINGLE_CAPITAL = /^\p{Lu}$/u;
+
+/**
+ * 文の途中の大文字 1 字の冠詞（at site A the connection、Peer A our copy）は、名前にした文字。冠詞は文の途中で大文字にならない。
+ * 同じ語（site A a）と文頭の A the は書き損じのまま。
+ */
+export const isLetterName = (first: Token, second: Token, opensSentence: boolean): boolean =>
+  !opensSentence && SINGLE_CAPITAL.test(first.surface) && !sameWord(first, second);
+
+/** 文の最初の、字のある語の位置。at 語目より前に字のある語が無ければ、at 語目は文の書き出し。 */
+const firstWordIndex = (tokens: readonly Token[]): number => tokens.findIndex((token) => LETTER.test(token.surface));
 
 const repeatsPrevious = (tokens: readonly Token[], at: number): boolean => {
   const [previous, token] = [tokens[at - 1], tokens[at]];
@@ -110,14 +121,18 @@ export const opensPhrase = (tokens: readonly Token[], at: number, phrases: Lexic
     return words.length > 1 && surfacesOf(tokens.slice(at, at + words.length)) === surfacesOf(words);
   });
 
-export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon, phrases: Lexicon = []): Doubled[] =>
-  tokens.flatMap((second, index) => {
+export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon, phrases: Lexicon = []): Doubled[] => {
+  const firstWord = firstWordIndex(tokens);
+  return tokens.flatMap((second, index) => {
     const first = tokens[index - 1];
     if (first === undefined || !doubledAt(source, first, second, spaced)) return [];
     if (isAllowed(tokens, index - 1, allowedAt(tokens, index - 1, allowed))) return [];
     if (!sameWord(first, second) && opensPhrase(tokens, index, phrases)) return [];
-    return isNameBefore(first, second, opensSentence(tokens, index - 1)) ? [] : [{ first, second }];
+    // first は字のある語なので、firstWord は見つかっていて index - 1 以下。
+    const opens = firstWord >= index - 1;
+    return isNameBefore(first, second, opens) || isLetterName(first, second, opens) ? [] : [{ first, second }];
   });
+};
 
 /** 印を挟んでいても（the [the）、見せるのは二語だけ。 */
 const wordOf = (doubled: Doubled, spaced: boolean): string => [doubled.first.surface, doubled.second.surface].join(spaced ? " " : "");

package/src/detectors/duplicate-heading.ts

@@ -0,0 +1,47 @@
+import type { Detector, Finding, MarkupHeading } from "../plugin.ts";
+import { lineNumberAt, linesOf } from "../structure/lines.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+
+/** 見出しの言葉を比べる形。全角と半角、大文字と小文字、空白の数は同じ見出しの違いにしない。 */
+export const headingKey = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+/** 見出しの親（一つ前の、それより浅い見出し）の位置。いちばん浅い見出しは文書が親で、-1。 */
+const parentIndexes = (headings: readonly MarkupHeading[]): number[] => {
+  const open: number[] = [];
+  const depthAt = (at: number | undefined): number => (at === undefined ? 0 : (headings[at]?.depth ?? 0));
+  return headings.map((heading, index) => {
+    while (open.length > 0 && depthAt(open.at(-1)) >= heading.depth) open.pop();
+    const parent = open.at(-1) ?? -1;
+    open.push(index);
+    return parent;
+  });
+};
+
+export type RepeatedHeading = { readonly heading: MarkupHeading; readonly first: MarkupHeading };
+
+type Seen = Map<number, Map<string, MarkupHeading>>;
+
+/**
+ * 同じ親の下で、前の見出しと同じ言葉の見出し（markdownlint の MD024 siblings_only）。変更履歴の版ごとの「Added」「Fixed」のように、
+ * 親が違えば同じ言葉でもよい。深さが違っても親が同じなら兄弟として比べる（飛んだ深さの見出しも同じ親の下にある）。
+ */
+export const repeatedSiblingHeadings = (headings: readonly MarkupHeading[]): RepeatedHeading[] => {
+  const parents = parentIndexes(headings);
+  const seen: Seen = new Map();
+  return headings.flatMap((heading, index) => {
+    const key = headingKey(heading.text);
+    const parent = parents[index] ?? -1;
+    const siblings = seen.get(parent) ?? new Map<string, MarkupHeading>();
+    seen.set(parent, siblings);
+    const first = siblings.get(key);
+    if (first === undefined) siblings.set(key, heading);
+    return first === undefined || key === "" ? [] : [{ heading, first }];
+  });
+};
+
+export const duplicateHeading: Detector = (doc): Finding[] => {
+  const lines = linesOf(doc.source);
+  return repeatedSiblingHeadings(writtenHeadings(doc)).map(({ heading, first }) =>
+    findingAt(doc, heading, { heading: heading.text, firstLine: lineNumberAt(lines, first.start) ?? 0 }),
+  );
+};

package/src/detectors/empty-section.ts

@@ -0,0 +1,21 @@
+import type { Detector, Finding, MarkupHeading } from "../plugin.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+
+/** HTML のコメント（「<!-- 後で書く -->」）。読み手には見えない。一つずつ外す（間の本文ごと一つのコメントと読まない）。 */
+const HTML_COMMENT = /<!--[\s\S]*?-->/gu;
+
+const showsNothing = (written: string): boolean => written.replace(HTML_COMMENT, "").trim() === "";
+
+/**
+ * 中身の無い節。見出しのすぐ後ろに、同じ深さか浅い見出しが来るもの（remark-lint の no-empty-sections）。
+ * 深い見出しが続くのは、節を小さな節に分けただけなので中身がある。文書の最後の見出しは、後ろに何も無ければ空。
+ */
+export const emptySections = (source: string, headings: readonly MarkupHeading[]): MarkupHeading[] =>
+  headings.filter((heading, index) => {
+    const next = headings[index + 1];
+    if (next !== undefined && next.depth > heading.depth) return false;
+    return showsNothing(source.slice(heading.end, next?.start ?? source.length));
+  });
+
+export const emptySection: Detector = (doc): Finding[] =>
+  emptySections(doc.source, writtenHeadings(doc)).map((heading) => findingAt(doc, heading, { heading: heading.text }));

package/src/detectors/enumerated-runs.ts

@@ -12,10 +12,19 @@ const labelOf = (node: StructureNode): string => {
  * 条の外で、番号の付いた行（言語パッケージが項目と読んだ「（1）」など）。
  * 条の中の番号付きの行は、条の項（条の本文の続き）でもありうるので数えない。
  */
-export const numberedStarts = (node: StructureNode, inArticle = false): NumberedStart[] => [
-  ...(node.kind === "item" && !inArticle ? [{ start: node.span.start, label: labelOf(node) }] : []),
-  ...node.children.flatMap((child) => numberedStarts(child, inArticle || node.kind === "article")),
-];
+export const numberedStarts = (root: StructureNode, inArticle = false): NumberedStart[] => {
+  const found: NumberedStart[] = [];
+  const pending = [{ node: root, inArticle }];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === undefined) break;
+    const { node } = next;
+    if (node.kind === "item" && !next.inArticle) found.push({ start: node.span.start, label: labelOf(node) });
+    const within = next.inArticle || node.kind === "article";
+    node.children.toReversed().forEach((child) => pending.push({ node: child, inArticle: within }));
+  }
+  return found;
+};
 
 const INDENT = /^[ \t\u3000]*/u;
 

package/src/detectors/fullwidth-alnum.ts

@@ -0,0 +1,118 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import { minorityWithin } from "../orthography.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { isCitation } from "./kutoten-consistency.ts";
+
+/** 英字と数字の並び。半角（ABC123）と全角（ＡＢＣ１２３）。 */
+const ALNUM_RUN = /[A-Za-z0-9Ａ-Ｚａ-ｚ０-９]+/gu;
+const FULLWIDTH = /^[Ａ-Ｚａ-ｚ０-９]+$/u;
+const HALFWIDTH = /^[A-Za-z0-9]+$/u;
+const LETTER = /[A-Za-zＡ-Ｚａ-ｚ]/u;
+
+/**
+ * 比べる組。英字と数字を分け、一字だけの並びと二字以上の並びも分ける。「１桁は全角、２桁以上は半角」「一字の英字（Ａ案）は全角」と
+ * 決めている文書は、組の中ではそろっている。
+ */
+export type AlnumKind = "letter" | "letters" | "digit" | "digits";
+
+const kindOf = (run: string): AlnumKind => {
+  const single = [...run].length === 1;
+  if (LETTER.test(run)) return single ? "letter" : "letters";
+  return single ? "digit" : "digits";
+};
+
+/** 項目の番号の並び（行の頭や括弧の後ろの「１．」「（１）」「1)」）。項目の印で、本文の数ではない。 */
+const LABEL_BEFORE = /(?:^|[\s、，,（(［[])$/u;
+const LABEL_AFTER = /^[．.）)］\]]/u;
+const LABEL_REACH = 1;
+
+/** 注の印（「※１」「（※３）」）。注どうしで決まった書き方をする。 */
+const NOTE_MARK = /[※＊*]$/u;
+
+/** 箇条書きの項目の頭（「- ４「勧告」…」）。目次の番号で、本文の数ではない。 */
+const LIST_ITEM_HEAD = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+$/u;
+
+const isLabel = (text: string, start: number, end: number): boolean =>
+  (LABEL_BEFORE.test(text.slice(Math.max(0, start - LABEL_REACH), start)) && LABEL_AFTER.test(text.slice(end, end + LABEL_REACH))) ||
+  NOTE_MARK.test(text.slice(0, start));
+
+/**
+ * メールアドレスやドメイン名の一部（support@example.com の support・example・com）。字の幅を変えると宛先が壊れる。
+ * 点の向こうが英字のときだけ名前の区切りと見る。数の小数点（39.4）は数として数える。
+ */
+const LETTER_BESIDE = /[A-Za-zＡ-Ｚａ-ｚ]/u;
+
+const isInAddress = (text: string, start: number, end: number): boolean =>
+  text.charAt(start - 1) === "@" ||
+  text.charAt(end) === "@" ||
+  (text.charAt(start - 1) === "." && LETTER_BESIDE.test(text.charAt(start - 2))) ||
+  (text.charAt(end) === "." && LETTER_BESIDE.test(text.charAt(end + 1)));
+
+/** 英字の後ろに数字を続けた名前（TLS1、Python3）と、その後ろの点でつないだ番号（Python3.12）。版の番号の頭になる。 */
+const VERSION_SO_FAR = /[A-Za-zＡ-Ｚａ-ｚ][0-9０-９]+(?:\.[0-9０-９]+)*$/u;
+
+/** 版の番号を後ろ向きに読む長さの上限。長い行で点ごとに行の頭から読み直さない。 */
+const VERSION_REACH = 32;
+
+/** 版の番号の続き（TLS1.2 の 2、Python3.12.4 の 12 と 4）。名前の数字と同じ幅なら、幅は名前に従い、文書の数の書き方の票にはしない（TLS1.２ の ２ は数える）。 */
+const continuesVersion = (text: string, start: number, run: string): boolean =>
+  text.charAt(start - 1) === "." &&
+  FULLWIDTH.test(run) === FULLWIDTH.test(text.charAt(start - 2)) &&
+  VERSION_SO_FAR.test(text.slice(Math.max(0, start - 1 - VERSION_REACH), start - 1));
+
+const isListItemNumber = (source: string, offset: number): boolean => LIST_ITEM_HEAD.test(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset));
+
+export type AlnumRun = { readonly kind: AlnumKind; readonly fullwidth: boolean; readonly written: string; readonly offset: number };
+
+/**
+ * 文の中の英字・数字の並び。全角と半角が混ざった並び、鉤括弧で引いたものの中、項目と注の番号、箇条書きの頭の番号、版の番号の続き（TLS1.2 の 2）は数えない。
+ * offset は文書の中の位置。
+ */
+export const alnumRunsIn = (sentence: Sentence, source: string): AlnumRun[] => {
+  const quoted: readonly Span[] = quotedSpans(sentence.text, QUOTATION_MARKS);
+  return [...sentence.text.matchAll(ALNUM_RUN)]
+    .filter((match) => FULLWIDTH.test(match[0]) || HALFWIDTH.test(match[0]))
+    .filter((match) => !isWithinAny(quoted, { start: match.index, end: match.index + match[0].length }))
+    .filter((match) => !isLabel(sentence.text, match.index, match.index + match[0].length))
+    .filter((match) => !isListItemNumber(source, sentence.span.start + match.index))
+    .filter((match) => !isInAddress(sentence.text, match.index, match.index + match[0].length))
+    .filter((match) => !continuesVersion(sentence.text, match.index, match[0]))
+    .map((match) => ({ kind: kindOf(match[0]), fullwidth: FULLWIDTH.test(match[0]), written: match[0], offset: sentence.span.start + match.index }));
+};
+
+const KINDS: readonly AlnumKind[] = ["letter", "letters", "digit", "digits"];
+
+/** 半角の英数字を全角に（NFKC の逆）。 */
+const FULLWIDTH_OFFSET = 0xfee0;
+const toFullwidth = (text: string): string => text.replace(/[A-Za-z0-9]/gu, (char) => String.fromCodePoint((char.codePointAt(0) ?? 0) + FULLWIDTH_OFFSET));
+
+/** 同じ並びの、もう一方の幅の書き方。 */
+const otherWidth = (run: AlnumRun): string => (run.fullwidth ? run.written.normalize("NFKC") : toFullwidth(run.written));
+
+type Located = { readonly sentence: Sentence; readonly run: AlnumRun };
+
+const findingOf = ({ sentence, run }: Located, count: number, of: number, limit: number): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { written: run.written, other: otherWidth(run), count, of, limit, offset: run.offset },
+  variant: run.fullwidth ? "fullwidth" : "halfwidth",
+});
+
+/**
+ * 英字・数字を全角で書くか半角で書くか。組（英字一字・英字の語・数字一字・数字の並び）ごとに、文書の中で少ないほうを指摘する。
+ * 少ないほうが組の limit パーセントを超えるほど多いなら、文書が使い分けている（数え方の語や見出しの書き方）と見て言わない。
+ * どちらが正しいかは決めない。
+ */
+export const fullwidthAlnum: Detector = (doc, options): Finding[] => {
+  const located: Located[] = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined && !isCitation(sentence, doc.source))
+    .flatMap((sentence) => alnumRunsIn(sentence, doc.source).map((run) => ({ sentence, run })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter(({ run }) => run.kind === kind);
+    const odd = minorityWithin(ofKind, ({ run }) => run.fullwidth, options.limit);
+    return odd.map((entry) => findingOf(entry, odd.length, ofKind.length, options.limit));
+  });
+};