chaffjs 0.17.0 → 0.19.0

package/src/detectors/phrase-match.ts

@@ -1,5 +1,6 @@
 import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
-import { entryIn } from "./lexicon-match.ts";
+import { entryEnds, entryIn } from "./lexicon-match.ts";
+import { closingSentences } from "../closing-paragraph.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
 const OPENING_SENTENCES = 4;
@@ -10,7 +11,7 @@ const OPENING_SENTENCES = 4;
  */
 const inScope = (doc: ProseDocument, where: string | undefined): readonly Sentence[] => {
   if (where === "opening") return doc.sentences.slice(0, OPENING_SENTENCES);
-  if (where === "closing") return doc.sections.at(-1)?.sentences ?? [];
+  if (where === "closing") return closingSentences(doc.sections, doc.paragraphs);
   return doc.sentences;
 };
 
@@ -22,14 +23,14 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+const findingsOf = (hits: readonly Hit[], limit: number, count = hits.length): Finding[] =>
   hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count, limit, offset: hit.sentence.span.start },
   }));
 
 const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
@@ -46,8 +47,27 @@ export const phraseMatch: Detector = (doc, options): Finding[] => {
   return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
 };
 
-/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+type Uses = { readonly sentence: Sentence; readonly matched: string; readonly count: number };
+
+/**
+ * 文の中の出現の数。語彙の語が重なっても（「させていただく」と「せていただく」）、終わる位置が同じなら一回。
+ * 指摘が言う語は文の最初の出現のもの。同じ位置なら語彙表で先に書いた語（させていただく）。
+ */
+const usesIn = (sentence: Sentence, lexicon: Lexicon): Uses | undefined => {
+  const found = lexicon.map((entry) => ({ entry, ends: entryEnds(sentence, entry) })).filter(({ ends }) => ends.length > 0);
+  const first = found.toSorted((a, b) => Math.min(...a.ends) - Math.min(...b.ends))[0];
+  if (first === undefined) return undefined;
+  return { sentence, matched: first.entry.pattern, count: new Set(found.flatMap(({ ends }) => ends)).size };
+};
+
+/**
+ * 回数に上限がある語。数えるのは文ではなく出現で、一文に二度あれば二回。limit は許す回数で、それを超えたときだけ言う。
+ * message の「N 回まで」と同じ向き。指摘は出現のある文ごとに一つ。
+ */
 export const phraseCount: Detector = (doc, options): Finding[] => {
-  const hits = phraseHits(doc, options);
-  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
+  const lexicon = options.lexicon ?? [];
+  const uses = inScope(doc, options.where).flatMap((sentence) => usesIn(sentence, lexicon) ?? []);
+  const total = uses.reduce((sum, use) => sum + use.count, 0);
+  if (total <= options.limit) return [];
+  return findingsOf(uses, options.limit, total);
 };

package/src/detectors/place-run.ts

@@ -20,10 +20,13 @@ type Run = { readonly tokens: readonly Token[]; readonly last: number; readonly
  * 閉じれば、そこまでが 1 つの地名。連なりの外（「に」「の」も 1 字）までは読まない。
  */
 const closedByUnit = (run: Run, index: number): boolean => {
-  const token = run.tokens[index];
-  if (index > run.last || token === undefined) return false;
-  if (isGeoUnit(token)) return !run.topUnits.has(token.surface);
-  return isNamePiece(token) && closedByUnit(run, index + 1);
+  for (let at = index; at <= run.last; at += 1) {
+    const token = run.tokens[at];
+    if (token === undefined) return false;
+    if (isGeoUnit(token)) return !run.topUnits.has(token.surface);
+    if (!isNamePiece(token)) return false;
+  }
+  return false;
 };
 
 /**

package/src/detectors/placeholder-text.ts

@@ -0,0 +1,27 @@
+import type { Lexicon } from "../plugin.ts";
+
+type Span = { readonly start: number; readonly end: number };
+
+/** 雛形の空欄を囲む括弧。記号の形で、どの言語でも同じ。 */
+const BRACKETED = /\[([^[\]\n]{1,60})\]|【([^【】\n]{1,30})】|［([^［］\n]{1,30})］/gu;
+
+/**
+ * 括弧のすぐ後ろ。Markdown のリンク（[text](url)、[text][ref]）と参照の定義（[ref]: url）、
+ * 値が続く見出しの札（【氏名】山田、【日付】2024年）は空欄ではない。助詞（【会社名】の）や空白・句読点が続くなら空欄。
+ */
+const FILLED_AFTER = /^[([:：\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}]/u;
+
+const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
+
+/** 括弧の中身が語彙表の語そのものか、その語で始まって空白・アポストロフィが続くか（[Your Name]、[Insert Date]）。 */
+const holdsWord = (inner: string, words: Lexicon): boolean =>
+  words.some((word) => {
+    const pattern = word.pattern.toLowerCase();
+    return inner === pattern || (inner.startsWith(pattern) && /^[\s'’]/u.test(inner.slice(pattern.length)));
+  });
+
+/** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】）の範囲。words は空欄に書く語。 */
+export const placeholderSpans = (text: string, words: Lexicon): Span[] =>
+  [...text.matchAll(BRACKETED)]
+    .filter((match) => !FILLED_AFTER.test(text.slice(match.index + match[0].length)) && holdsWord(innerOf(match), words))
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/quote-around.ts

@@ -0,0 +1,9 @@
+/** 見せる前後の字数。記号 1 つの指摘は、周りの言葉が無いとどこか分からない。 */
+const QUOTE_REACH = 20;
+
+/** text の start から end の前後を、空白をならして引く。 */
+export const quoteAround = (text: string, start: number, end: number = start + 1): string =>
+  text
+    .slice(Math.max(0, start - QUOTE_REACH), end + QUOTE_REACH)
+    .replace(/\s+/gu, " ")
+    .trim();

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/register.ts

@@ -15,21 +15,32 @@ const chainAtEnd = (preceding: readonly Token[]): readonly Token[] => {
   return preceding.slice(Math.max(head, 0));
 };
 
+/** 語彙表 neutral-ending の語（「こと」）か。書いた形か原形で照らす。 */
+const isNeutralWord = (token: Token | undefined, neutral: readonly LexiconEntry[]): boolean =>
+  token !== undefined && neutral.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern);
+
 /**
- * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「予約できること。」「おかけしましたこと。」は手前の述語が調子を持つ。
- * 要件や規程のである調は「〜こと。」で書く。「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「使っているのかな？」は手前の述語が調子を持つ。
+ * 「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 語彙表 neutral-ending の語（「こと」）で終わる文末は手前を見ない。「〜を保持すること。」は体言止めで、要件や規程の箇条書きは
+ * ですます調の文書でもである調の文書でもこの形で書く。
  */
-const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): readonly Token[] =>
-  isDependent(ending[0]) ? [...chainAtEnd(preceding), ...ending] : ending;
+const withPreceding = (ending: readonly Token[], preceding: readonly Token[], neutral: readonly LexiconEntry[]): readonly Token[] =>
+  isDependent(ending[0]) && !isNeutralWord(ending[0], neutral) ? [...chainAtEnd(preceding), ...ending] : ending;
 
 /**
- * 文末の語の調子。preceding は文末の語より前の語。
+ * 文末の語の調子。preceding は文末の語より前の語。neutral は調子を持たない文末の語（語彙表 neutral-ending）。
  * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
  * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
  * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
  */
-export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
-  const judged = withPreceding(ending, preceding);
+export const registerOf = (
+  ending: readonly Token[],
+  preceding: readonly Token[],
+  polite: readonly LexiconEntry[],
+  neutral: readonly LexiconEntry[] = [],
+): Register | undefined => {
+  const judged = withPreceding(ending, preceding, neutral);
   if (!judged.some(isPredicate)) return undefined;
   return judged.some((token) => isPoliteWord(token, polite)) ? "polite" : "plain";
 };
@@ -56,21 +67,36 @@ export const groupOf = (offset: number, lists: readonly Span[], runs: readonly S
 /** group: 文が入っているまとまり（groupOf の値）。本文なら undefined。 */
 export type Judged = { readonly register: Register; readonly group: number | undefined };
 
-/** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
+/** 混ざった文と、その文が属するまとまり（本文、または箇条書き 1 つ）の中の少数派の数。文書全体の数ではない。 */
 export type Slip<T extends Judged> = { readonly entry: T; readonly count: number };
 
 const countIn = (judged: readonly Judged[], register: Register): number => judged.filter((entry) => entry.register === register).length;
 
+/** 多いほう。同数なら undefined。 */
+export const majorityOf = (judged: readonly Judged[]): Register | undefined => {
+  const difference = countIn(judged, "polite") - countIn(judged, "plain");
+  if (difference === 0) return undefined;
+  return difference > 0 ? "polite" : "plain";
+};
+
 /** 少ないほう。同数なら文書全体で少ないほう、それも同数なら丁寧体。 */
 const minorityOf = (group: readonly Judged[], whole: readonly Judged[]): Register => {
-  const difference = countIn(group, "polite") - countIn(group, "plain");
-  if (difference !== 0) return difference < 0 ? "polite" : "plain";
+  const majority = majorityOf(group);
+  if (majority !== undefined) return majority === "polite" ? "plain" : "polite";
   return countIn(whole, "polite") <= countIn(whole, "plain") ? "polite" : "plain";
 };
 
+/**
+ * 箇条書きの中の少数派が、文書全体では多数派か。それなら箇条書きの中で文書の調子に寄せた側なので、直す側ではない。
+ * 常体の多い箇条書きにですます調の文が混ざっても、ですます調の文書なら「多いほうに揃えて」は文書の少数派へ揃えることになる。
+ */
+export const followsDocument = (group: number | undefined, minority: Register, whole: readonly Judged[]): boolean =>
+  group !== undefined && majorityOf(whole) === minority;
+
 const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | undefined, limit: number): Slip<T>[] => {
   const members = judged.filter((entry) => entry.group === group);
   const minority = minorityOf(members, judged);
+  if (followsDocument(group, minority, judged)) return [];
   const slips = members.filter((entry) => entry.register === minority);
   // 片方しか無ければ揃っている。少数派が閾値を超えて多ければ、混在ではなく別の文体。
   if (slips.length === 0 || slips.length > limit) return [];
@@ -80,6 +106,7 @@ const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | un
 /**
  * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きと番号で始まる段落の並びは 1 つずつ、その中で揃っているかを見る。
  * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
+ * 箇条書きの中で混ざっていても、少数派が文書全体の多数派なら指さない（followsDocument）。
  */
 export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {
   const slips = [...new Set(judged.map((entry) => entry.group))].flatMap((group) => slipsInGroup(judged, group, limit));

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/roman-numeral.ts

@@ -3,3 +3,6 @@
  * 各桁が省けるので空文字にも当たる。1 文字目があることを先読みで求める。
  */
 export const ROMAN_NUMERAL = "(?=[MDCLXVI])M{0,4}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})";
+
+/** ハイフンかダッシュで繋いだ数字の範囲（II-VI、I–III）も、一つの番号として読む。 */
+export const romanRangeOf = (numeral: string): string => `${numeral}(?:[-–]${numeral})?`;

package/src/detectors/sentence-ending.ts

@@ -12,11 +12,11 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[]): Register | undefined => {
+const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[], neutral: readonly LexiconEntry[]): Register | undefined => {
   const ending = endingTokens(sentence);
   const tokens = sentence.tokens ?? [];
   const head = ending[0] === undefined ? -1 : tokens.indexOf(ending[0]);
-  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite);
+  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite, neutral);
 };
 
 /** 番号で始まる段落の並び。木を組むのは高いので、調子が一つだけの文書（混ざりようがない）では組まない。 */
@@ -30,25 +30,32 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
   );
 };
 
-export const sentenceEnding: Detector = (doc, options): Finding[] => {
-  const polite = options.lexicon ?? [];
+/** 調子を持つ文と、比べ合うまとまり（groupOf）。polite は語彙表 polite-ending。 */
+export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntry[]): Entry[] => {
+  const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
   const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
     if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
-    const register = registerOfSentence(sentence, polite);
+    const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),
   );
-  const judged = found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
-  return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
+  return found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
+};
+
+export const sentenceEnding: Detector = (doc, options): Finding[] => {
+  const judged = judgedSentences(doc, options.lexicon ?? []);
+  // 数えたのは文が属するまとまりの中なので、文言もそのまとまりを名指す（本文の中で / この箇条書きの中で）。
+  return slipsOf(judged, options.limit).map(({ entry: { sentence, group }, count }) => ({
     rule: "no-mixed-desumasu",
     severity: "warning",
     line: 0,
     column: 0,
     quote: sentence.text.trim(),
+    ...(group === undefined ? {} : { variant: "list" }),
     values: { count, limit: options.limit, offset: sentence.span.start },
   }));
 };

package/src/detectors/sentence-length.ts

@@ -1,15 +1,26 @@
 import { lengthOf, proseText } from "../measure.ts";
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+
+type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
+
+/** 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。 */
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions): Measure => {
+  const embedded = sentence.embeddedLanguage;
+  const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
+  if (embedded === undefined || limit === undefined) return { size: lengthOf(sentence, unit), limit: options.limit };
+  return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
+};
 
 export const sentenceLength: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, size: lengthOf(sentence, doc.lengthUnit) }))
-    .filter(({ size }) => size > options.limit)
-    .map(({ sentence, size }) => ({
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options) }))
+    .filter(({ measure }) => measure.size > measure.limit)
+    .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",
       severity: "warning",
       line: 0,
       column: 0,
       quote: proseText(sentence),
-      values: { count: size, limit: options.limit, offset: sentence.span.start },
+      values: { count: measure.size, limit: measure.limit, offset: sentence.span.start },
+      ...(measure.variant === undefined ? {} : { variant: measure.variant }),
     }));