chaffjs 0.19.0 → 0.20.0

package/src/detectors/orthographic-variant.ts

@@ -0,0 +1,152 @@
+import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
+import { kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { isKatakanaWord, stemOf } from "../long-vowel.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+
+/** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
+type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
+
+type IsOpen = (start: number, end: number) => boolean;
+
+/** Parts of speech that carry a word of their own. Particles and endings are written one way by the grammar. */
+const CONTENT = new Set(["NOUN", "VERB", "ADJ", "ADV", "PRON", "CCONJ", "DET"]);
+const JAPANESE_WORD = /^[\p{Script=Han}々ぁ-ゖァ-ヺー]+$/u;
+/** A one-mora reading (木 and き, 気) is too short to say two spellings are one word. */
+const MIN_READING = 2;
+/** A katakana key shorter than this meets other words (ビル and ビール). */
+const MIN_KATAKANA_KEY = 4;
+const MIN_LATIN_KEY = 3;
+
+/** Lexicons: readings and spellings whose kanji and kana forms mean different things (成る and なる, 者 and もの), and adverbs hiragana-fukushi reads. */
+const DISTINCT = "orthographic-variant-distinct";
+const FUKUSHI = "hiragana-fukushi";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** Whether a stretch of the sentence is outside a quotation and outside the team's names, both of which keep their own spelling. */
+const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
+  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const named = nameSpans(sentence.text, names);
+  return (start, end) => !isWithinAny(quoted, { start, end }) && !touchesAny(named, start, end);
+};
+
+const isHelper = (token: Token, previous: Token | undefined): boolean =>
+  token.features?.["Bound"] === "Yes" || (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で"));
+
+/**
+ * A helper verb or a dependent noun (見て下さい, その事) is written kana by many guides while the full word keeps its kanji (資料を下さい).
+ * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用) is a third use:
+ * it is not the dependent noun of the same reading (このように).
+ */
+const useOf = (token: Token, previous: Token | undefined): string => {
+  if (!isHelper(token, previous)) return "free";
+  return token.pos === "NOUN" && token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
+};
+
+const readingKeyOf = (token: Token, previous: Token | undefined, skip: ReadonlySet<string>): string | undefined => {
+  const lemma = token.lemma;
+  if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
+  const reading = lemmaReading(token.surface, lemma, token.reading);
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading)) return undefined;
+  return `${token.pos}|${useOf(token, previous)}|${reading}`;
+};
+
+/** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
+const readingWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const tokens = sentence.tokens ?? [];
+  return tokens.flatMap((token, at): Placed[] => {
+    const key = readingKeyOf(token, tokens[at - 1], skip);
+    const local = token.span.start - sentence.span.start;
+    if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
+    return [{ key, spelling: token.lemma, sentence, offset: token.span.start }];
+  });
+};
+
+/**
+ * Same reading is not yet same word: 書く and 描く are both カク. Spellings meet only when they keep the same kanji (引っ越し, 引越し)
+ * or one is all kana. A kana spelling joins the kanji one only when the reading has a single kanji spelling in the document;
+ * with two (橋 and 箸 beside はし) it cannot say which, and is left out.
+ */
+const byKanji = (words: readonly Placed[]): Placed[] =>
+  [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
+    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
+    return group.flatMap((word): Placed[] => {
+      const own = kanjiSkeleton(word.spelling);
+      if (own === "" && skeletons.length > 1) return [];
+      return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}` }];
+    });
+  });
+
+/** Katakana nouns keyed with small kana and ー evened out, spelled without the final ー that katakana-long-vowel reads. */
+const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  (sentence.tokens ?? []).flatMap((token): Placed[] => {
+    const local = token.span.start - sentence.span.start;
+    if (token.pos !== "NOUN" || !isKatakanaWord(token.surface) || !isOpen(local, local + token.surface.length)) return [];
+    const key = katakanaKey(token.surface);
+    return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
+  });
+
+const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
+const LOWER = /\p{Ll}/u;
+
+/**
+ * The case of the first letter of each part is left out of the spelling: a sentence, a title or a name gives it (Email and email,
+ * Long-Term and long-term), the writer does not. Capitals after it are the spelling (GitHub and Github).
+ */
+const latinSpelling = (word: string): string =>
+  word
+    .split("-")
+    .map((part) => part.charAt(0).toLowerCase() + part.slice(1))
+    .join("-");
+
+/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
+const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
+
+const isPartOfAddress = (text: string, start: number, end: number): boolean =>
+  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && /\w/u.test(text.charAt(end + 1)));
+
+/**
+ * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
+ * emphasis or an acronym, not a spelling of the word, and is left out.
+ */
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
+  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+    const word = match[0];
+    const plain = word.toLowerCase().replaceAll("-", "");
+    const end = match.index + word.length;
+    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || skip.has(word.toLowerCase())) return [];
+    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
+    return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
+  });
+
+/** How the usual spelling is written where it first appears (gitHub is shown GitHub). */
+const shownUsual = (words: readonly Placed[], { word, usual }: OddSpelling<Placed>): string =>
+  words.find((other) => other.key === word.key && other.spelling === usual)?.shown ?? usual;
+
+const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: odd.word.sentence.text.trim(),
+  values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
+});
+
+/**
+ * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
+ * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
+ * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
+ */
+export const orthographicVariant: Detector = (doc, options): Finding[] => {
+  const skip = new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]);
+  const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skip)));
+  const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skip));
+  const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
+  const all = [...reading, ...katakana, ...latin];
+  // A word can be odd by its reading and by its katakana key at once; one place is said once.
+  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+};

package/src/detectors/paragraph-restatement.ts

@@ -0,0 +1,68 @@
+// A paragraph that announces a restatement (つまり, このように, In other words) and then mostly repeats the paragraph
+// before it. Pure; measured in content morphemes by base form, the way heading-echo measures a heading. The announcing
+// words come from the language's restating-opener lexicon.
+import { newContentMorphemes } from "./content-morphemes.ts";
+import type { Detector, Finding, Paragraph, ProseDocument, Token } from "../plugin.ts";
+
+/** A paragraph with fewer content words than this says too little to measure. */
+const MIN_CONTENT_WORDS = 4;
+
+const PERCENT = 100;
+
+/** What may follow the opener: a comma, a space or the end; in Japanese also the next word straight away (つまり実行時に). */
+const AFTER_OPENER = /^(?:$|[\s、，,:：]|[^\p{Script=Latin}])/u;
+
+/** The opener a paragraph starts with, as written, or undefined. Case is folded; the longest opener wins. */
+export const openerOf = (text: string, openers: readonly string[]): string | undefined => {
+  const trimmed = text.trimStart();
+  const folded = trimmed.toLowerCase();
+  const found = openers
+    .filter((opener) => folded.startsWith(opener.toLowerCase()) && AFTER_OPENER.test(trimmed.slice(opener.length)))
+    .toSorted((left, right) => right.length - left.length)[0];
+  return found === undefined ? undefined : trimmed.slice(0, found.length);
+};
+
+/** The share of the later tokens' content words, in percent, that the earlier tokens already hold (by base form). */
+export const repeatedShare = (earlier: readonly Token[], later: readonly Token[]): { readonly share: number; readonly words: number } => {
+  const words = newContentMorphemes([], later);
+  if (words === 0) return { share: 0, words };
+  return { share: Math.round(((words - newContentMorphemes(earlier, later)) / words) * PERCENT), words };
+};
+
+const tokensOf = (paragraph: Paragraph): Token[] => paragraph.sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/** The paragraph's tokens past its opener: the opener itself is not what the paragraph says. */
+const tokensAfterOpener = (paragraph: Paragraph, opener: string): Token[] => {
+  const [first, ...rest] = paragraph.sentences;
+  if (first === undefined) return [];
+  const openerEnd = first.text.length - first.text.trimStart().length + opener.length;
+  return [...(first.tokens ?? []).filter((token) => token.span.end > openerEnd), ...rest.flatMap((sentence) => sentence.tokens ?? [])];
+};
+
+/** Two paragraphs with only blank lines between: no heading, list, table or code separates them. */
+const isNextTo = (doc: ProseDocument, earlier: Paragraph, later: Paragraph): boolean => doc.source.slice(earlier.span.end, later.span.start).trim() === "";
+
+const findingOf = (paragraph: Paragraph, opener: string, share: number, limit: number): Finding => {
+  const first = paragraph.sentences[0];
+  const lead = first === undefined ? 0 : first.text.length - first.text.trimStart().length;
+  return {
+    rule: "paragraph-restatement",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: first?.text.trim() ?? "",
+    values: { opener, share, limit, offset: (first?.span.start ?? paragraph.span.start) + lead },
+  };
+};
+
+/** Each paragraph that opens with a restating word and repeats at least limit percent of the previous paragraph's words. */
+export const paragraphRestatement: Detector = (doc, options): Finding[] => {
+  const openers = (doc.lexicons["restating-opener"] ?? []).map((entry) => entry.pattern);
+  return doc.paragraphs.flatMap((later, index): Finding[] => {
+    const earlier = doc.paragraphs[index - 1];
+    const opener = openerOf(later.sentences[0]?.text ?? "", openers);
+    if (earlier === undefined || opener === undefined || !isNextTo(doc, earlier, later)) return [];
+    const { share, words } = repeatedShare(tokensOf(earlier), tokensAfterOpener(later, opener));
+    return words >= MIN_CONTENT_WORDS && share >= options.limit ? [findingOf(later, opener, share, options.limit)] : [];
+  });
+};

package/src/detectors/paragraph-run.ts

@@ -0,0 +1,27 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { oneSentenceRuns } from "../paragraph-runs.ts";
+
+/** How much of the run's first paragraph the finding quotes. */
+const QUOTE_LENGTH = 80;
+
+/**
+ * Runs of one-sentence paragraphs longer than the limit: every sentence set apart as its own paragraph, so nothing is grouped
+ * and the reader cannot see which points belong together. One finding per run, at its first paragraph.
+ */
+export const oneSentenceParagraphRun: Detector = (doc, options): Finding[] =>
+  oneSentenceRuns(doc.source, doc.paragraphs)
+    .filter((run) => run.length > options.limit)
+    .flatMap((run) => {
+      const first = run[0];
+      if (first === undefined) return [];
+      return [
+        {
+          rule: "",
+          severity: "info",
+          line: 0,
+          column: 0,
+          quote: doc.source.slice(first.span.start, first.span.start + QUOTE_LENGTH).trim(),
+          values: { count: run.length, limit: options.limit, offset: first.span.start },
+        },
+      ];
+    });

package/src/detectors/person-consistency.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { personMentions, personMinorities, type PersonMention, type PersonWords } from "../person-forms.ts";
+
+const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords => ({
+  words,
+  forms: doc.lexicons["person-form"] ?? [],
+  notAfter: doc.lexicons["person-not-after"] ?? [],
+});
+
+/**
+ * One document naming itself (私たち / 弊社, 私 / 筆者) or its reader (you / one) two ways: the minority form of each slot.
+ * Sentences in another language than the document's are left out; quotations are left out by personMentions.
+ */
+export const personMix: Detector = (doc, options): Finding[] => {
+  const person = wordsOf(doc, options.lexicon ?? []);
+  const entries: { readonly sentence: Sentence; readonly mention: PersonMention }[] = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined)
+    .flatMap((sentence) => personMentions(sentence.text, person).map((mention) => ({ sentence, mention })));
+  return personMinorities(entries, options.limit).flatMap(({ odd, usual, of }) =>
+    odd.map(({ sentence, mention }) => ({
+      rule: "",
+      severity: "info" as const,
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: mention.written, usual, count: odd.length, of, limit: options.limit, offset: sentence.span.start + mention.at },
+    })),
+  );
+};

package/src/detectors/placeholder-text.ts

@@ -5,12 +5,31 @@ type Span = { readonly start: number; readonly end: number };
 /** 雛形の空欄を囲む括弧。記号の形で、どの言語でも同じ。 */
 const BRACKETED = /\[([^[\]\n]{1,60})\]|【([^【】\n]{1,30})】|［([^［］\n]{1,30})］/gu;
 
+/** 書き手への指示を囲む丸括弧（（ここに会社名を書く））。丸括弧は説明にも使うので、語彙表の instruction の語で始まるときだけ数える。 */
+const PARENTHESIZED = /\(([^()\n]{1,60})\)|（([^（）\n]{1,60})）/gu;
+
 /**
  * 括弧のすぐ後ろ。Markdown のリンク（[text](url)、[text][ref]）と参照の定義（[ref]: url）、
  * 値が続く見出しの札（【氏名】山田、【日付】2024年）は空欄ではない。助詞（【会社名】の）や空白・句読点が続くなら空欄。
  */
 const FILLED_AFTER = /^[([:：\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}]/u;
 
+/** What may stand around a marker that is the whole value: quotes and brackets, a closing stop. */
+const OPENING = /^[\s"'“‘「『(（[［【]*/u;
+const CLOSERS: ReadonlySet<string> = new Set("\"'”’」』)）]］】.。!！");
+const COLON_NEXT = /^\s*[:：]/u;
+
+/** text without the quotes, brackets, stops and spaces that close it. */
+const withoutClosers = (text: string): string => {
+  const chars = [...text];
+  const last = chars.findLastIndex((char) => !CLOSERS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+/** Lexicon groups of placeholder-word. An entry without a group is a word written inside a template's brackets. */
+const MARKER = "marker";
+const INSTRUCTION = "instruction";
+
 const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
 
 /** 括弧の中身が語彙表の語そのものか、その語で始まって空白・アポストロフィが続くか（[Your Name]、[Insert Date]）。 */
@@ -20,8 +39,46 @@ const holdsWord = (inner: string, words: Lexicon): boolean =>
     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 }));
+/** 括弧の中身が指示の書き出しで始まるか（ここに会社名を書く）。 */
+const opensWith = (inner: string, words: Lexicon): boolean => words.some((word) => inner.startsWith(word.pattern.toLowerCase()));
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const bracketedSpans = (text: string, pattern: RegExp, holds: (inner: string) => boolean): Span[] =>
+  [...text.matchAll(pattern)].filter((match) => !FILLED_AFTER.test(text.slice(match.index + match[0].length)) && holds(innerOf(match))).map(spanOf);
+
+/**
+ * A value left as a marker: the whole text is the marker ("TBD", 「未定」), or the marker opens it before a colon
+ * ("TBD: owner"), in any case. Only the start of a value counts, so a marker word inside a sentence is not one.
+ * The span runs to the end of the value, quotes and the closing stop left out, so the finding quotes the whole note.
+ * A checklist task ("[ ] TBD: …") and a comment ("// TBD") keep their mark in front, so the marker does not open them.
+ */
+const markerSpans = (text: string, markers: Lexicon): Span[] => {
+  const start = OPENING.exec(text)?.[0].length ?? 0;
+  const rest = text.slice(start);
+  const marker = markers.find((entry) => rest.toLowerCase().startsWith(entry.pattern.toLowerCase()));
+  if (marker === undefined) return [];
+  const after = rest.slice(marker.pattern.length);
+  if (withoutClosers(after) === "") return [{ start, end: start + marker.pattern.length }];
+  if (!COLON_NEXT.test(after)) return [];
+  return [{ start, end: start + withoutClosers(rest).length }];
+};
+
+/** Each line of a sentence on its own: values a line apart ("TBD: owner" then "TBD: date") are two blanks, not one. */
+const lineMarkerSpans = (text: string, markers: Lexicon): Span[] =>
+  text.split("\n").flatMap((line, index, lines) => {
+    const offset = lines.slice(0, index).reduce((sum, previous) => sum + previous.length + 1, 0);
+    return markerSpans(line, markers).map((span) => ({ start: span.start + offset, end: span.end + offset }));
+  });
+
+/** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】、（ここに会社名を書く）、TBD: …）の範囲。words は placeholder-word の語彙表。 */
+export const placeholderSpans = (text: string, words: Lexicon): Span[] => {
+  const bracketWords = words.filter((word) => word.group === undefined);
+  const instructions = words.filter((word) => word.group === INSTRUCTION);
+  const markers = words.filter((word) => word.group === MARKER);
+  return [
+    ...bracketedSpans(text, BRACKETED, (inner) => holdsWord(inner, bracketWords)),
+    ...(instructions.length === 0 ? [] : bracketedSpans(text, PARENTHESIZED, (inner) => opensWith(inner, instructions))),
+    ...lineMarkerSpans(text, markers),
+  ].toSorted((left, right) => left.start - right.start);
+};

package/src/detectors/reference-text.ts

@@ -0,0 +1,44 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { inDocumentOrder, referenceResolver, type StructureIssue } from "../structure/issues.ts";
+import { titleMismatches, topicMisses, type ReferenceInput } from "../structure/reference-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** 文書の中の参照と、参照先の引き方。他の文書の名が付いた参照（民法第709条）は、この文書の見出しと比べない。 */
+const inputOf = (doc: ProseDocument): ReferenceInput | undefined => {
+  const tree = doc.structure;
+  if (tree === undefined) return undefined;
+  return {
+    source: doc.source,
+    references: inDocumentOrder(tree).filter((node) => node.kind === "reference" && node.attrs["document"] === undefined),
+    targetOf: referenceResolver(tree),
+    words: {
+      asides: patternsOf(doc, "reference-aside"),
+      topicLinks: patternsOf(doc, "reference-topic-link"),
+      vagueTopics: patternsOf(doc, "reference-topic-vague"),
+    },
+  };
+};
+
+const findingsOf =
+  (rule: string, issuesOf: (input: ReferenceInput) => StructureIssue[]): Detector =>
+  (doc): Finding[] => {
+    const input = inputOf(doc);
+    return input === undefined
+      ? []
+      : issuesOf(input).map((issue) => ({
+          rule,
+          severity: "warning",
+          line: 0,
+          column: 0,
+          quote: quoteAt(doc.source, issue.offset),
+          values: { ...issue.values, offset: issue.offset },
+        }));
+  };
+
+/** 「第2章「料金」」の名前が、第2章の見出しと合わない。 */
+export const referenceTitleMismatch: Detector = findingsOf("reference-title-mismatch", titleMismatches);
+
+/** 「第2章で述べた料金体系」の話題が、第2章に無い。 */
+export const referenceTopicMissing: Detector = findingsOf("reference-topic-missing", topicMisses);

package/src/detectors/registry/absolute-exception.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { absoluteException } from "../absolute-exception.ts";
+
+export const detector: Detector = absoluteException;

package/src/detectors/registry/abstract-length.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { abstractLength } from "../abstract-length.ts";
+
+export const detector: Detector = abstractLength;

package/src/detectors/registry/acronym-expansion-conflict.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { acronymExpansionConflict } from "../definition-use.ts";
+
+export const detector: Detector = acronymExpansionConflict;

package/src/detectors/registry/adverb-density.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { adverbDensity } from "../en-shape.ts";
+
+export const detector: Detector = adverbDensity;

package/src/detectors/registry/agentless-passive.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { agentlessPassive } from "../agentless-passive.ts";
+
+export const detector: Detector = agentlessPassive;

package/src/detectors/registry/agreement-slip.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { agreementSlip } from "../agreement-slip.ts";
+
+export const detector: Detector = agreementSlip;

package/src/detectors/registry/ai-structure.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { aiStructure } from "../ai-structure.ts";
+
+export const detector: Detector = aiStructure;

package/src/detectors/registry/ai-tell.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { aiTell } from "../lexicon.ts";
+
+export const detector: Detector = aiTell;

package/src/detectors/registry/announced-count.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { announcedCount } from "../announced-count.ts";
+
+export const detector: Detector = announcedCount;

package/src/detectors/registry/article-sound.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { articleSound } from "../next-word.ts";
+
+export const detector: Detector = articleSound;

package/src/detectors/registry/assistant-residue.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { assistantResidue } from "../ai-phrasing.ts";
+
+export const detector: Detector = assistantResidue;

package/src/detectors/registry/bold-label-list.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { boldLabelList } from "../bold-label.ts";
+
+export const detector: Detector = boldLabelList;

package/src/detectors/registry/bracket-nesting.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { bracketNesting } from "../sentence-load.ts";
+
+export const detector: Detector = bracketNesting;

package/src/detectors/registry/broken-link.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { brokenLink } from "../broken-link.ts";
+
+export const detector: Detector = brokenLink;

package/src/detectors/registry/chat-citation-residue.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { chatCitationResidue } from "../chat-citation.ts";
+
+export const detector: Detector = chatCitationResidue;

package/src/detectors/registry/citation-entry.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { citationEntry } from "../citation-entry.ts";
+
+export const detector: Detector = citationEntry;

package/src/detectors/registry/citation-style.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { citationStyle } from "../citation-style.ts";
+
+export const detector: Detector = citationStyle;

package/src/detectors/registry/clause-chain.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { clauseChain } from "../sentence-load.ts";
+
+export const detector: Detector = clauseChain;

package/src/detectors/registry/colon-lead-in.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { colonLeadIn } from "../ai-phrasing.ts";
+
+export const detector: Detector = colonLeadIn;

package/src/detectors/registry/concrete-evidence.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { concreteEvidence } from "../signals.ts";
+
+export const detector: Detector = concreteEvidence;

package/src/detectors/registry/conjunction-run.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { conjunctionRun } from "../en-shape.ts";
+
+export const detector: Detector = conjunctionRun;

package/src/detectors/registry/contraction-mix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { contractionMix } from "../lexicon.ts";
+
+export const detector: Detector = contractionMix;

package/src/detectors/registry/contrast-framing.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { contrastFraming } from "../ai-phrasing.ts";
+
+export const detector: Detector = contrastFraming;

package/src/detectors/registry/count-per-section.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { countPerSection } from "../count-per-section.ts";
+
+export const detector: Detector = countPerSection;

package/src/detectors/registry/cushion-density.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { cushionDensity } from "../lexicon.ts";
+
+export const detector: Detector = cushionDensity;

package/src/detectors/registry/custom-pattern.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { customPattern } from "../custom.ts";
+
+export const detector: Detector = customPattern;

package/src/detectors/registry/custom-tokens.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { customTokens } from "../custom.ts";
+
+export const detector: Detector = customTokens;

package/src/detectors/registry/custom-words.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { customWords } from "../custom.ts";
+
+export const detector: Detector = customWords;

package/src/detectors/registry/dangling-figure.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { danglingFigure } from "../dangling-figure.ts";
+
+export const detector: Detector = danglingFigure;

package/src/detectors/registry/dangling-reference.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { danglingReference } from "../structure-tree.ts";
+
+export const detector: Detector = danglingReference;

package/src/detectors/registry/dash-density.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dashDensity } from "../signals.ts";
+
+export const detector: Detector = dashDensity;

package/src/detectors/registry/date-format.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateFormat } from "../date-format.ts";
+
+export const detector: Detector = dateFormat;

package/src/detectors/registry/date-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateOrder } from "../structure-tree.ts";
+
+export const detector: Detector = dateOrder;

package/src/detectors/registry/date-range-reversed.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateRangeReversed } from "../structure-tree.ts";
+
+export const detector: Detector = dateRangeReversed;

package/src/detectors/registry/date-weekday-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateWeekdayMismatch } from "../structure-tree.ts";
+
+export const detector: Detector = dateWeekdayMismatch;

package/src/detectors/registry/date-without-year.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateWithoutYear } from "../date-year.ts";
+
+export const detector: Detector = dateWithoutYear;