chaffjs 0.18.0 → 0.20.0

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

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

package/src/detectors/registry/phrase-match.ts

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

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

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

package/src/detectors/registry/preferred-term.ts

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

package/src/detectors/registry/proper-noun-density.ts

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

package/src/detectors/registry/ra-nuki.ts

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

package/src/detectors/registry/reference-title-mismatch.ts

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

package/src/detectors/registry/reference-topic-missing.ts

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

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

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

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

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

package/src/detectors/registry/repeated-head.ts

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

package/src/detectors/registry/required-sections.ts

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

package/src/detectors/registry/requirement-modal.ts

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

package/src/detectors/registry/requirement-smell.ts

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

package/src/detectors/registry/rule-of-three.ts

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

package/src/detectors/registry/section-uniformity.ts

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

package/src/detectors/registry/sentence-comma-count.ts

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

package/src/detectors/registry/sentence-conjunctive-count.ts

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

package/src/detectors/registry/sentence-ending.ts

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

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

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

package/src/detectors/registry/sentence-rhythm.ts

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

package/src/detectors/registry/sentence-word-count.ts

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

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

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

package/src/detectors/registry/spelling-variety.ts

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

package/src/detectors/registry/stock-transition.ts

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

package/src/detectors/registry/stray-space.ts

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

package/src/detectors/registry/summary-fact-mismatch.ts

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

package/src/detectors/registry/table-header-variant.ts

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

package/src/detectors/registry/title-case-mix.ts

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

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

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

package/src/detectors/registry/topic-predicate-distance.ts

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

package/src/detectors/registry/total-mismatch.ts

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

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

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

package/src/detectors/registry/undefined-acronym.ts

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

package/src/detectors/registry/unfilled-placeholder.ts

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

package/src/detectors/registry/unit-mismatch.ts

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

package/src/detectors/registry/unknown-word.ts

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

package/src/detectors/registry/unqualified-superlative.ts

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

package/src/detectors/registry/unused-definition.ts

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

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

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

package/src/detectors/registry/use-before-definition.ts

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

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

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

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

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

package/src/detectors/registry/vague-link-text.ts

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

package/src/detectors/registry-files.ts

@@ -0,0 +1,12 @@
+/** A file in detectors/registry/ and the how_to_find it serves: its name without the extension. */
+export type RegistryEntry = { readonly file: string; readonly howToFind: string };
+
+/**
+ * The registry files among a directory's names, in name order. Only names ending in the extension of the running module
+ * count: from src that is .ts, from dist .js, where the .d.ts and .map files beside them are not detectors.
+ */
+export const registryEntries = (names: readonly string[], extension: string): RegistryEntry[] =>
+  names
+    .filter((name) => name.endsWith(extension) && !name.endsWith(`.d${extension}`) && name.length > extension.length)
+    .toSorted((left, right) => left.localeCompare(right, "en"))
+    .map((file) => ({ file, howToFind: file.slice(0, -extension.length) }));

package/src/detectors/registry-load.ts

@@ -0,0 +1,23 @@
+import { existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { registryEntries } from "./registry-files.ts";
+
+// require (not import) keeps a registry ready synchronously, without a top-level await in every importer.
+const requireModule = createRequire(import.meta.url);
+
+const detectorOf = (loaded: unknown): unknown => (typeof loaded === "object" && loaded !== null && "detector" in loaded ? loaded.detector : undefined);
+
+/**
+ * The detectors of a registry directory, one file per how_to_find, each exporting a function named detector.
+ * extension is that of the running module (.ts from src, .js from dist). A directory that is not there holds none.
+ */
+export const loadRegistry = <T>(dir: string, extension: string, isDetector: (value: unknown) => value is T): Readonly<Record<string, T>> =>
+  Object.fromEntries(
+    registryEntries(existsSync(dir) ? readdirSync(dir) : [], extension).map(({ file, howToFind }) => {
+      const path = join(dir, file);
+      const detector = detectorOf(requireModule(path));
+      if (!isDetector(detector)) throw new Error(`chaff: ${path} must export a function named detector`);
+      return [howToFind, detector];
+    }),
+  );

package/src/detectors/relative-dates.ts

@@ -0,0 +1,113 @@
+import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
+const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
+  ["duration-day", "day"],
+  ["duration-week", "week"],
+  ["duration-month", "month"],
+  ["duration-year", "year"],
+  ["relative-year-unit", "year"],
+];
+
+type Amount = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const unitOf = (doc: ProseDocument, written: string): DurationUnit | undefined => {
+  const unit = written.normalize("NFKC").toLowerCase();
+  return DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC").toLowerCase() === unit))?.[1];
+};
+
+/** 数のすぐ後ろ（空白一つまで）に書いた単位まで。木の数量は単位の前で終わることがある（3 days の 3）。 */
+const endWithUnit = (source: string, end: number, unit: string): number => {
+  const gap = source.charAt(end) === " " || source.charAt(end) === "\t" ? 1 : 0;
+  return unit !== "" && source.startsWith(unit, end + gap) ? end + gap + unit.length : end;
+};
+
+const treeAmounts = (doc: ProseDocument, tree: StructureNode): Amount[] =>
+  inDocumentOrder(tree).flatMap((node): Amount[] => {
+    const written = String(node.attrs["unit"] ?? "");
+    const unit = node.kind === "quantity" ? unitOf(doc, written) : undefined;
+    if (unit === undefined) return [];
+    return [{ start: node.span.start, end: endWithUnit(doc.source, node.span.end, written), amount: Number(node.attrs["value"]), unit }];
+  });
+
+/** 語で書いた数（two weeks）。count-number の語彙表は一から順に並ぶので、位置が数。 */
+/** 数の語と、その後ろの単位の語。単位は先読みで読むので、語を二つずつ食べずに、どの語も数の語として試せる。 */
+const WORD_AMOUNT = /(?<![\p{L}\p{N}])(\p{L}+)(?=([ \t]+)(\p{L}+)(?![\p{L}\p{N}]))/gu;
+
+const wordAmounts = (doc: ProseDocument, taken: readonly Span[]): Amount[] => {
+  const numbers = patternsOf(doc, "count-number").map((word) => word.toLowerCase());
+  const index = spanIndex(taken);
+  return [...doc.source.matchAll(WORD_AMOUNT)].flatMap((match): Amount[] => {
+    const position = numbers.indexOf((match[1] ?? "").toLowerCase());
+    const unit = unitOf(doc, match[3] ?? "");
+    const span = { start: match.index, end: match.index + (match[1] ?? "").length + (match[2] ?? "").length + (match[3] ?? "").length };
+    return position === -1 || unit === undefined || overlapsAny(index, span) ? [] : [{ ...span, amount: position + 1, unit }];
+  });
+};
+
+const LATIN = /^[a-z ]+$/iu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** 期間のすぐ後ろの、向きの語（後、later）。英字の語は空白を挟んで、語の切れ目まで。 */
+const directionOf = (doc: ProseDocument, amount: Amount): 1 | -1 | undefined => {
+  const after = doc.source.slice(amount.end, amount.end + 20).toLowerCase();
+  const matches = (word: string): boolean => {
+    const lower = word.toLowerCase();
+    if (!LATIN.test(word)) return after.startsWith(lower);
+    return after.startsWith(` ${lower}`) && !WORD_CHAR.test(after.charAt(lower.length + 1));
+  };
+  if (patternsOf(doc, "relative-after").some(matches)) return 1;
+  return patternsOf(doc, "relative-before").some(matches) ? -1 : undefined;
+};
+
+/** 向きの語まで含めた相対の期間。 */
+const relativesOf = (doc: ProseDocument, amounts: readonly Amount[]): Relative[] =>
+  amounts.flatMap((amount): Relative[] => {
+    const direction = directionOf(doc, amount);
+    if (direction === undefined) return [];
+    const words = patternsOf(doc, direction === 1 ? "relative-after" : "relative-before");
+    const after = doc.source.slice(amount.end).toLowerCase();
+    const word = words.find((candidate) => after.trimStart().startsWith(candidate.toLowerCase())) ?? "";
+    const end = amount.end + (after.length - after.trimStart().length) + word.length;
+    return [{ ...amount, end, direction }];
+  });
+
+const datesOf = (tree: StructureNode): DatedValue[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+/** 相対で書いた日付（3日後の10月5日）が、基準の日付から数えた日と合わない。 */
+export const relativeDateMismatch: Detector = (doc): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const dates = datesOf(tree);
+  const fromTree = treeAmounts(doc, tree);
+  const amounts = [...fromTree, ...wordAmounts(doc, [...fromTree, ...dates])];
+  const input = {
+    source: doc.source,
+    sentences: doc.sentences.map((sentence) => sentence.span),
+    dates,
+    relatives: relativesOf(doc, amounts),
+    links: patternsOf(doc, "relative-link"),
+  };
+  return relativeMismatches(input).map((mismatch) => ({
+    rule: "relative-date-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.target.start),
+    values: {
+      base: doc.source.slice(mismatch.base.start, mismatch.base.end),
+      relative: doc.source.slice(mismatch.relative.start, mismatch.relative.end),
+      target: doc.source.slice(mismatch.target.start, mismatch.target.end),
+      expected: mismatch.expected,
+      offset: mismatch.target.start,
+    },
+  }));
+};

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));
+};