chaffjs 0.16.0 → 0.18.0

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,22 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { danglingFigures, 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);
+
+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"),
+});
+
+/** 本文が指す図・表・付録の番号が、キャプションにも見出しにも無い。 */
+export const danglingFigure: Detector = (doc): Finding[] =>
+  danglingFigures(doc.source, doc.prose ?? doc.source, labelWordsOf(doc), doc.links).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/doubled-punctuation.ts

@@ -0,0 +1,49 @@
+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 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) && !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/en-shape.ts

@@ -134,272 +134,3 @@ export const titleCaseMix: Detector = (doc, options): Finding[] => {
     values: { count: few.length, limit: options.limit, offset: section.span.start },
   }));
 };
-
-const LIST_CONJUNCTION = new Set(["and", "or"]);
-
-const isComma = (token: Token): boolean => token.surface === ",";
-
-const commaBefore = (tokens: readonly Token[], at: number): boolean => tokens[at - 1]?.surface === ",";
-
-/** 並列はこれをまたがない。セミコロンの前後は別の節。 */
-const CLAUSE_BREAK = new Set([";", ":", "—"]);
-
-/** 各 token の前で閉じていない括弧の数。括弧の中の読点（external users (e.g., guests), and ...）は外の並列を切らない。 */
-const PAREN_STEP: Readonly<Record<string, number>> = { "(": 1, ")": -1 };
-
-const depthsOf = (tokens: readonly Token[]): number[] =>
-  tokens.reduce<{ depths: number[]; open: number }>(
-    (acc, token) => ({ depths: [...acc.depths, acc.open], open: Math.max(0, acc.open + (PAREN_STEP[token.surface] ?? 0)) }),
-    { depths: [], open: 0 },
-  ).depths;
-
-/** participleWords は、解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）。 */
-type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[]; readonly participleWords: ReadonlySet<string> };
-
-/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
-const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
-
-const isContent = (token: Token): boolean => token.pos !== "DET" && token.pos !== "PUNCT" && token.pos !== "X";
-
-const shapeOf = (item: readonly Token[]): string | undefined => {
-  const head = item.find(isContent);
-  if (head === undefined) return undefined;
-  return NOMINAL.has(head.pos) ? "NOMINAL" : head.pos;
-};
-
-const VERBAL = new Set(["VERB", "AUX"]);
-
-/** 主語と述語のある項目。the team fixed the bug / these are crucial。gets us more は述語だけ。 */
-const isClause = (item: readonly Token[]): boolean => {
-  const first = item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
-  if (first === undefined || !(first.pos === "DET" || NOMINAL.has(first.pos))) return false;
-  return item.some((token) => token !== first && VERBAL.has(token.pos));
-};
-
-/** 節の頭から and / or の手前までを、同じ深さの読点で項目に切る。Oxford comma の読点のあとは空なので項目にならない。 */
-const itemsBefore = (clause: Clause, at: number): Token[][] => {
-  const level = clause.depths[at] ?? 0;
-  const start = clause.tokens.slice(0, at).findLastIndex((token) => CLAUSE_BREAK.has(token.surface)) + 1;
-  return clause.tokens
-    .slice(start, at)
-    .reduce<Token[][]>(
-      (items, token, offset) => {
-        if (isComma(token) && clause.depths[start + offset] === level) return [...items, []];
-        return [...items.slice(0, -1), [...(items.at(-1) ?? []), token]];
-      },
-      [[]],
-    )
-    .filter((item) => item.length > 0);
-};
-
-/**
- * and / or で始まる項目で、前の並びは閉じている（offering, giving, or receiving, directly or indirectly）。
- * 次の並びはその項目から始まる。項目が動詞で始まれば、その目的語から（Develop, maintain, and track courses, materials and events）。
- */
-const afterClosedList = (items: readonly Token[][]): Token[][] => {
-  const closed = items.findLastIndex((item) => LIST_CONJUNCTION.has(openingOf(item)?.surface.toLowerCase() ?? ""));
-  const closing = items[closed];
-  if (closing === undefined) return [...items];
-  const body = closing.slice(closing.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase())) + 1);
-  const head = body.findIndex(isContent);
-  const rest = VERBAL.has(body[head]?.pos ?? "") ? body.slice(head + 1) : body;
-  // 項目が残らなければ、後ろは新しい句の頭。導入の句（directly or indirectly,）を外す。
-  return rest.some(isContent) ? [rest, ...items.slice(closed + 1)] : [...withoutLead(items.slice(closed + 1))];
-};
-
-/** and / or の後ろの項目。次の読点か節の切れ目まで。 */
-const itemAfter = (tokens: readonly Token[], at: number): Token[] => {
-  const end = tokens.findIndex((token, index) => index > at && (isComma(token) || CLAUSE_BREAK.has(token.surface)));
-  return tokens.slice(at + 1, end === -1 ? undefined : end);
-};
-
-/**
- * 導入の句（After the review, / If it fails, / Finally, / To test it, / Based on the review,）は並列の項目ではない。
- * 節の最初の項目が前置詞・接続詞・副詞・to・過去分詞で始まり、次の項目と頭の形が違えば外す。
- * Quickly, quietly and carefully は残る。For managers, engineers and designers, も外れるが、前置詞のあとの名詞を
- * 項目と読むと、Over this period, the subcommittees and the full committee ... を並びと誤る。こちらのほうが多い。
- */
-const LEAD_POS = new Set(["ADP", "SCONJ", "ADV", "PART"]);
-
-const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part";
-
-const openingOf = (item: readonly Token[]): Token | undefined => item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
-
-const openingKind = (item: readonly Token[]): string | undefined => {
-  const opening = openingOf(item);
-  return opening !== undefined && isParticiple(opening) ? "PARTICIPLE" : shapeOf(item);
-};
-
-const withoutLead = (items: readonly Token[][]): readonly Token[][] => {
-  const [first, second] = items;
-  const opening = first === undefined ? undefined : openingOf(first);
-  if (first === undefined || second === undefined || opening === undefined) return items;
-  if (!LEAD_POS.has(opening.pos) && !isParticiple(opening)) return items;
-  return openingKind(first) === openingKind(second) ? items : items.slice(1);
-};
-
-/**
- * 形容詞のあとの読点は、名詞の前で形容詞を重ねているだけのことが多い（the long, winding bridge）。
- * 次の項目が名詞で終わるならつなげ直す。形容詞そのものの並び（quick, cheap and reliable）は切ったまま。
- */
-const lastContent = (item: readonly Token[]): Token | undefined => item.findLast(isContent);
-
-const joinAdjectives = (items: readonly Token[][]): Token[][] =>
-  items.reduce<Token[][]>((joined, item) => {
-    const previous = joined.at(-1);
-    const stacked = previous !== undefined && lastContent(previous)?.pos === "ADJ" && lastContent(item)?.pos !== "ADJ";
-    if (stacked) joined[joined.length - 1] = [...previous, ...item];
-    else joined.push(item);
-    return joined;
-  }, []);
-
-/**
- * 節を並べるなら、どの項目も節。Additionally, others can learn, and the mistake is rarer. の
- * Additionally は項目ではなく、and の前の読点は節をつなぐ読点。名詞の並びは最初の項目に前置き
- * （We shipped the parser）を抱えるので、この確かめは節の並びだけにする。
- * and の後ろだけが節なのは主語の並び（The parser, the renderer and the exporter shipped.）なので外さない。
- */
-const clausesAgree = (items: readonly Token[][], after: readonly Token[]): boolean => {
-  const last = items.at(-1);
-  if (last === undefined || !isClause(last)) return true;
-  return isClause(after) && items.every(isClause);
-};
-
-/**
- * 動詞で始まる項目を並べるなら、どの項目にも動詞がある。The scope, in contrast, is larger, and covers ... の
- * The scope は項目ではなく、後ろの述語の主語。
- */
-const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL.has(token.pos));
-
-const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
-
-/** -ing 形（VerbForm=Ger）と過去分詞（Part）。filling the gaps と sentenced to prison は並べても並列にならない。 */
-const VERB_FORMS = new Set(["Ger", "Part"]);
-
-const verbFormOf = (token: Token): string | undefined => {
-  const form = token.features?.["VerbForm"];
-  return form !== undefined && VERB_FORMS.has(form) ? form : undefined;
-};
-
-/** 項目の頭の分詞とその形。副詞は飛ばす（originally written）。引用符の中の語（‘modelling’）は語の例なので分詞と読まない。 */
-const participleOpening = (item: readonly Token[], words: ReadonlySet<string>): { readonly at: number; readonly form: string } | undefined => {
-  const at = item.findIndex((token) => token.pos !== "PUNCT" && token.pos !== "ADV");
-  const opening = item[at];
-  if (opening === undefined) return undefined;
-  const form = words.has(opening.surface.toLowerCase()) ? "Ger" : verbFormOf(opening);
-  return form === undefined ? undefined : { at, form };
-};
-
-const hasParticiple = (item: readonly Token[], form: string): boolean => item.some((token) => verbFormOf(token) === form);
-
-/**
- * 最初より後ろの項目が分詞で始まるとき。最初の項目にも同じ形の分詞があれば分詞の並び
- * （are hiring engineers, buying laptops and renting desks / Tested, reviewed and approved）。後ろの項目が動詞で始まれば述語の並びで、
- * 分詞は解析器の読み違い（the jury, cross-examined the witnesses, presented witnesses, and made）。そうでなければ分詞の句
- * （from Latin, meaning ship or boat / the judge, sitting without a jury, and sentenced）で、並びがあるならその句の中から始まる。
- * 分詞より前の項目と分詞そのものは項目ではない（programs, including the office, the desk and the team）。句の中の項目の形が揃わなければ
- * 句は挿入で、並びは句の後ろだけ（relief, including an injunction, in any court ... and without / including before the date, to a
- * Recipient ... “confidential”, “proprietary”, or the like）。
- */
-/** 解析器は過去形と過去分詞（fixed）を見分けられない。動詞のある項目のあとの「過去分詞」の並びは、述語の並びと読む。 */
-const pastPredicates = (first: readonly Token[], form: string, after: readonly Token[], words: ReadonlySet<string>): boolean =>
-  form === "Part" && participleOpening(after, words)?.form === "Part" && hasVerb(first);
-
-const fromParticiplePhrase = (items: readonly Token[][], after: readonly Token[], words: ReadonlySet<string>): readonly Token[][] => {
-  const at = items.findIndex((item, index) => index > 0 && participleOpening(item, words) !== undefined);
-  const phrase = items[at];
-  const first = items[0];
-  const opening = phrase === undefined ? undefined : participleOpening(phrase, words);
-  if (first === undefined || phrase === undefined || opening === undefined) return items;
-  const rest = items.slice(at + 1);
-  const predicates = rest.some((item) => VERBAL.has(shapeOf(item) ?? "")) || pastPredicates(first, opening.form, after, words);
-  if (hasParticiple(first, opening.form) || predicates) return items;
-  const inPhrase = withoutLead([phrase.slice(opening.at + 1), ...rest].filter((item) => item.some(isContent)));
-  return new Set(inPhrase.map(shapeOf)).size > 1 ? rest : inPhrase;
-};
-
-const APPOSITIVE_ANCHOR = new Set(["NOUN", "PROPN"]);
-
-/**
- * 名詞のすぐ後ろの、読点で挟まれた X and Y は同格（two HPV types, HPV16 and HPV18, that account / Governments, both state and
- * federal, spend）。項目が 2 つに見え、and の前に読点が無く、and の後ろの項目が読点で閉じ、後ろの 2 つに動詞が無いときに同格と読む。
- * 2 つを結ぶ同格に Oxford comma は打たないので、and の前に読点があれば 3 つの並び（the subcommittee, full committee, and
- * chamber levels, as well as）。読点の無い本当の並び（apples, pears and plums, then ...）はこの形と見分けられず、判定から外れる。
- */
-const isAppositive = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
-  const [anchor, head] = items;
-  if (items.length !== 2 || anchor === undefined || head === undefined || commaBefore(clause.tokens, at)) return false;
-  const end = at + 1 + after.length;
-  // 閉じた読点のあとに and / or が続くなら、並びのあとに節をつないでいる（apples, pears and plums, and went home）。
-  const joinsClause = LIST_CONJUNCTION.has(clause.tokens[end + 1]?.surface.toLowerCase() ?? "");
-  const closed = clause.tokens[end]?.surface === "," && clause.depths[end] === clause.depths[at] && !joinsClause;
-  return closed && APPOSITIVE_ANCHOR.has(lastContent(anchor)?.pos ?? "") && !hasVerb(head) && !hasVerb(after);
-};
-
-/** 副詞を飛ばした頭の形。explain and justify と ultimately ensure は同じ動詞の項目。 */
-const leadShape = (item: readonly Token[]): string | undefined => shapeOf(item.filter((token) => token.pos !== "ADV"));
-
-/**
- * and の後ろの項目に読点と、同じ形の項目を連れた and / or が続くなら、この and は項目の中にある（searches and seizures, and
- * the Eighth's ban）。頭の形か、節かどうかが違えば別の節をつなぐ and で、この and までが並び（apples, pears and plums, and went home / and figs fell）。
- */
-const listContinues = (clause: Clause, at: number, after: readonly Token[]): boolean => {
-  const next = at + 1 + after.length;
-  if (clause.tokens[next]?.surface !== "," || !LIST_CONJUNCTION.has(clause.tokens[next + 1]?.surface.toLowerCase() ?? "")) return false;
-  const following = itemAfter(clause.tokens, next + 1);
-  const shape = leadShape(following);
-  return shape !== undefined && shape === leadShape(after) && isClause(following) === isClause(after);
-};
-
-/**
- * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
- * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
- * （We tested it, and the team shipped it.）は、Oxford comma を打つかどうかの選択を見せない。
- */
-const listAt = (clause: Clause, at: number): boolean | undefined => {
-  const after = itemAfter(clause.tokens, at);
-  const items = fromParticiplePhrase(afterClosedList(withoutLead(joinAdjectives(itemsBefore(clause, at)))), after, clause.participleWords);
-  if (listContinues(clause, at, after) || isAppositive(clause, at, items, after)) return undefined;
-  const last = items.at(-1);
-  const shape = last === undefined ? undefined : shapeOf(last);
-  if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
-  if (!clausesAgree(items, after) || !predicatesAgree(items, shape)) return undefined;
-  return commaBefore(clause.tokens, at);
-};
-
-/**
- * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
- *
- * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
- * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
- */
-const oxfordIn = (tokens: readonly Token[], participleWords: ReadonlySet<string>): boolean | undefined => {
-  const clause = { tokens, depths: depthsOf(tokens), participleWords };
-  return tokens.reduce<boolean | undefined>(
-    (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
-    undefined,
-  );
-};
-
-export const oxfordComma: Detector = (doc, options): Finding[] => {
-  const participleWords = new Set((doc.lexicons["participle-word"] ?? []).map((entry) => entry.pattern.toLowerCase()));
-  const judged = doc.sentences.flatMap((sentence) => {
-    const oxford = oxfordIn(sentence.tokens ?? [], participleWords);
-    return oxford === undefined ? [] : [{ sentence, oxford }];
-  });
-  const withComma = judged.filter((entry) => entry.oxford).length;
-  const minorityUsesComma = withComma <= judged.length - withComma;
-  const few = minorityUsesComma ? withComma : judged.length - withComma;
-  // 同数なら少数派は無い。
-  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.oxford === minorityUsesComma)
-    .map(({ sentence }) => ({
-      rule: "oxford-comma-consistency",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: sentence.text.trim(),
-      values: { count: few, limit: options.limit, offset: sentence.span.start },
-    }));
-};

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/gram-furniture.ts

@@ -0,0 +1,30 @@
+import type { Span } from "../plugin.ts";
+
+// ひな形が項目ごとに繰り返す飾り（一覧の札、リンクの文字、記号の並び）。書き手の言い回しではない。
+
+const MARK = /[\p{P}\p{S}]/gu;
+
+const BRACKETED = /[([{（［｛]([^()[\]{}（）［］｛｝]*)[)\]}）］｝]/gu;
+
+/** 札の 1 項目。空白を含まない 1 語で、平仮名も含まない（日本語で平仮名を含めば、括弧の中は言い回し）。 */
+const TAG_ITEM = /^\s*[^\s\p{Script=Hiragana}]+\s*$/u;
+
+/** 括弧の中が、1 語か 1 語ずつの並び（(replaced)、[pdf, html, other]）。(if applicable) のような句は札ではない。 */
+const isTag = (inside: string): boolean => inside.split(/[,、]/u).every((item) => TAG_ITEM.test(item));
+
+const spansOf = (text: string, pattern: RegExp, keep: (match: RegExpExecArray) => boolean): Span[] =>
+  [...text.matchAll(pattern)].filter(keep).map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** text の各位置（UTF-16 の単位）が飾りか。記号・句読点、括弧でくくった札、リンクの文字（linked が決める）。 */
+export const furnitureMask = (text: string, linked: (index: number) => boolean): boolean[] => {
+  const mask = Array.from({ length: text.length }, (_, index) => linked(index));
+  [...spansOf(text, MARK, () => true), ...spansOf(text, BRACKETED, (match) => isTag(match[1] ?? ""))].forEach((span) => mask.fill(true, span.start, span.end));
+  return mask;
+};
+
+/** 窓の中の空白でない文字の過半が飾りなら、その出現は飾り。 */
+export const isFurniture = (text: string, mask: readonly boolean[], window: Span): boolean => {
+  const visible = Array.from({ length: window.end - window.start }, (_, step) => window.start + step).filter((index) => !/\s/u.test(text[index] ?? ""));
+  const marked = visible.filter((index) => mask[index] === true);
+  return visible.length > 0 && marked.length * 2 > visible.length;
+};

package/src/detectors/gram-place.ts

@@ -37,12 +37,16 @@ export const compacted = (text: string, unit: LengthUnit): Compacted => {
   return { text: chars.join(""), offsets };
 };
 
+/** 詰めた文の中の範囲を、元の文の範囲に戻す。 */
+export const placeAt = (source: Compacted, window: Span): Span | undefined => {
+  const start = source.offsets[window.start];
+  const last = source.offsets[window.end - 1];
+  if (start === undefined || last === undefined) return undefined;
+  return { start, end: last + 1 };
+};
+
 /** 詰めた文の中の gram の最初の出現を、元の文の範囲に戻す。無ければ undefined。 */
 export const placeOf = (source: Compacted, gram: string): Span | undefined => {
   const at = source.text.indexOf(gram);
-  if (at === -1) return undefined;
-  const start = source.offsets[at];
-  const last = source.offsets[at + gram.length - 1];
-  if (start === undefined || last === undefined) return undefined;
-  return { start, end: last + 1 };
+  return at === -1 ? undefined : placeAt(source, { start: at, end: at + gram.length });
 };

package/src/detectors/gram-windows.ts

@@ -0,0 +1,31 @@
+import type { Span } from "../plugin.ts";
+
+/** 1 文字ずつずらした、幅 width の窓。 */
+export const charWindows = (text: string, width: number): Span[] =>
+  Array.from({ length: Math.max(0, text.length - width + 1) }, (_, start) => ({ start, end: start + width }));
+
+/** first 番目の語から数えて、minLength 文字に届く最初の語。届く前に尽きるのは minLength 文字に満たない末尾だけなので、深くならない。 */
+const reachingWord = (words: readonly Span[], first: number, minLength: number): Span | undefined => {
+  const start = words[first]?.start ?? 0;
+  const step = (index: number): Span | undefined => {
+    const word = words[index];
+    if (word === undefined || word.end - start >= minLength) return word;
+    return step(index + 1);
+  };
+  return step(first);
+};
+
+/** 語。前後の句読点と括弧は含めない。"described," と "described" を別の語句として数えないため。 */
+const WORD = /[\p{L}\p{N}](?:\S*[\p{L}\p{N}])?/gu;
+
+/**
+ * 語の頭で始まり語の尾で終わる窓。語を 1 つずつ足して、minLength 文字に届いた最短のもの。
+ * 文字で切ると " generat" や "roductivity change a" のような語の断片が数えられる。
+ */
+export const wordWindows = (text: string, minLength: number): Span[] => {
+  const words = [...text.matchAll(WORD)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  return words.flatMap((first, index) => {
+    const last = reachingWord(words, index, minLength);
+    return last === undefined ? [] : [{ start: first.start, end: last.end }];
+  });
+};