@mark1russell7/ste-lint 0.1.1 → 0.1.2

package/src/dictionary-core.ts

@@ -0,0 +1,158 @@
+/**
+ * The optional local dictionary of approved words.
+ *
+ * The ASD-STE100 dictionary is copyrighted. This package does not contain
+ * it, and the repository must not contain it. Each user makes a local file
+ * from their own copy of the standard. Keep that file outside the
+ * repository, or in a git-ignored folder, for example `.ste/`.
+ *
+ * File format (JSON). The short form is an array of approved words:
+ *
+ * ```json
+ * ["a", "about", "make", "makes", "made"]
+ * ```
+ *
+ * The full form is an object with entries:
+ *
+ * ```json
+ * {
+ *   "format": "ste-lint-dictionary",
+ *   "version": 1,
+ *   "entries": [
+ *     { "word": "make", "pos": "verb", "forms": ["makes", "made"] },
+ *     { "word": "valve", "pos": "noun" },
+ *     { "word": "utilize", "pos": "verb", "approved": false, "alternatives": ["use"] }
+ *   ]
+ * }
+ * ```
+ *
+ * - `word` (necessary): the headword. A phrase, for example "make sure", approves each of its words.
+ * - `pos`: the part of speech. A noun also permits its regular plural.
+ * - `approved`: `false` for a word that is not approved. The default is `true`.
+ * - `forms`: other approved forms, for example the past tense of a verb.
+ * - `alternatives`: approved words to use instead of a word that is not approved.
+ */
+
+export type DictionaryEntry = {
+    readonly word : string;
+    readonly pos? : string;
+    readonly approved? : boolean;
+    readonly forms? : readonly string[];
+    readonly alternatives? : readonly string[];
+};
+
+export type DictionaryLookup =
+    | { readonly status : "approved" }
+    | { readonly status : "not-approved"; readonly alternatives : readonly string[] }
+    | { readonly status : "unknown" };
+
+export const DICTIONARY_FORMAT = "ste-lint-dictionary";
+
+/** An error in a dictionary file. */
+export class DictionaryError extends Error {
+    override readonly name : string = "DictionaryError";
+}
+
+const normalize = (word : string) : string => word.trim().toLowerCase().replace(/[’‘]/g, "'");
+
+/** The approved words of a local dictionary. */
+export class Dictionary {
+    private readonly approved = new Set<string>();
+    private readonly approvedNouns = new Set<string>();
+    private readonly notApproved = new Map<string, readonly string[]>();
+    /** The approved nouns. The noun-cluster rule uses them. */
+    readonly nouns : Set<string> = new Set<string>();
+    /** The approved verbs. The imperative and missing-subject heuristics use them. */
+    readonly verbs : Set<string> = new Set<string>();
+
+    constructor(entries : readonly DictionaryEntry[]) {
+        for (const entry of entries) {
+            const words = [entry.word, ...(entry.forms ?? [])].flatMap((form) => normalize(form).split(/\s+/)).filter((form) => form.length > 0);
+            if (entry.approved === false) {
+                for (const word of words) this.notApproved.set(word, entry.alternatives ?? []);
+                continue;
+            }
+            for (const word of words) this.approved.add(word);
+            const pos = (entry.pos ?? "").toLowerCase();
+            const base = normalize(entry.word);
+            if (pos === "n" || pos === "noun") {
+                this.approvedNouns.add(base);
+                this.nouns.add(base);
+            }
+            if (pos === "v" || pos === "verb") this.verbs.add(base);
+        }
+    }
+
+    /** The number of approved words and forms. */
+    get size() : number {
+        return this.approved.size;
+    }
+
+    /** The status of `word` in the dictionary. */
+    lookup(word : string) : DictionaryLookup {
+        const lower = normalize(word);
+        const candidates = [lower];
+        if (lower.endsWith("'s")) candidates.push(lower.slice(0, -2));
+        for (const candidate of candidates) {
+            if (this.approved.has(candidate)) return { status : "approved" };
+            const plurals = [candidate.slice(0, -1), candidate.slice(0, -2), candidate.slice(0, -3) + "y"];
+            if (candidate.endsWith("s") && plurals.some((singular) => this.approvedNouns.has(singular))) return { status : "approved" };
+        }
+        for (const candidate of candidates) {
+            const alternatives = this.notApproved.get(candidate);
+            if (alternatives !== undefined) return { status : "not-approved", alternatives };
+        }
+        return { status : "unknown" };
+    }
+}
+
+/** This function makes a dictionary from parsed JSON. `source` is the file name for error messages. */
+export function parseDictionary(value : unknown, source : string) : Dictionary {
+    if (Array.isArray(value)) {
+        if (!value.every((word) => typeof word === "string")) {
+            throw new DictionaryError(`${source}: the array form must contain only strings.`);
+        }
+        return new Dictionary(value.map((word : string) => ({ word })));
+    }
+    if (typeof value !== "object" || value === null) {
+        throw new DictionaryError(`${source}: the file must contain an array of words or an object with "entries".`);
+    }
+    const record = value as Record<string, unknown>;
+    const format = record["format"];
+    if (format !== undefined && format !== DICTIONARY_FORMAT) {
+        throw new DictionaryError(`${source}: "format" must be "${DICTIONARY_FORMAT}".`);
+    }
+    const entries = record["entries"];
+    if (!Array.isArray(entries)) throw new DictionaryError(`${source}: "entries" must be an array.`);
+    const parsed : DictionaryEntry[] = entries.map((entry : unknown, index : number) => parseEntry(entry, `${source}: entries[${index}]`));
+    return new Dictionary(parsed);
+}
+
+function stringArray(value : unknown, where : string) : string[] | undefined {
+    if (value === undefined) return undefined;
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new DictionaryError(`${where} must be an array of strings.`);
+    }
+    return value as string[];
+}
+
+function parseEntry(entry : unknown, where : string) : DictionaryEntry {
+    if (typeof entry === "string") return { word : entry };
+    if (typeof entry !== "object" || entry === null) throw new DictionaryError(`${where} must be a string or an object.`);
+    const record = entry as Record<string, unknown>;
+    const word = record["word"];
+    if (typeof word !== "string" || word.trim().length === 0) throw new DictionaryError(`${where}.word must be a string that is not empty.`);
+    const pos = record["pos"];
+    if (pos !== undefined && typeof pos !== "string") throw new DictionaryError(`${where}.pos must be a string.`);
+    const approved = record["approved"];
+    if (approved !== undefined && typeof approved !== "boolean") throw new DictionaryError(`${where}.approved must be true or false.`);
+    const forms = stringArray(record["forms"], `${where}.forms`);
+    const alternatives = stringArray(record["alternatives"], `${where}.alternatives`);
+    return {
+        word,
+        ...(pos === undefined ? {} : { pos }),
+        ...(approved === undefined ? {} : { approved }),
+        ...(forms === undefined ? {} : { forms }),
+        ...(alternatives === undefined ? {} : { alternatives }),
+    };
+}

package/src/dictionary.ts

@@ -1,163 +1,12 @@
 /**
- * The optional local dictionary of approved words.
- *
- * The ASD-STE100 dictionary is copyrighted. This package does not contain
- * it, and the repository must not contain it. Each user makes a local file
- * from their own copy of the standard. Keep that file outside the
- * repository, or in a git-ignored folder, for example `.ste/`.
- *
- * File format (JSON). The short form is an array of approved words:
- *
- * ```json
- * ["a", "about", "make", "makes", "made"]
- * ```
- *
- * The full form is an object with entries:
- *
- * ```json
- * {
- *   "format": "ste-lint-dictionary",
- *   "version": 1,
- *   "entries": [
- *     { "word": "make", "pos": "verb", "forms": ["makes", "made"] },
- *     { "word": "valve", "pos": "noun" },
- *     { "word": "utilize", "pos": "verb", "approved": false, "alternatives": ["use"] }
- *   ]
- * }
- * ```
- *
- * - `word` (necessary): the headword. A phrase, for example "make sure", approves each of its words.
- * - `pos`: the part of speech. A noun also permits its regular plural.
- * - `approved`: `false` for a word that is not approved. The default is `true`.
- * - `forms`: other approved forms, for example the past tense of a verb.
- * - `alternatives`: approved words to use instead of a word that is not approved.
+ * The local dictionary file. The format and the lookup are in
+ * `dictionary-core.ts`, which a browser can use. This module reads the file.
  */
 
 import { readFileSync } from "node:fs";
+import { DictionaryError, parseDictionary, type Dictionary } from "./dictionary-core.js";
 
-export type DictionaryEntry = {
-    readonly word : string;
-    readonly pos? : string;
-    readonly approved? : boolean;
-    readonly forms? : readonly string[];
-    readonly alternatives? : readonly string[];
-};
-
-export type DictionaryLookup =
-    | { readonly status : "approved" }
-    | { readonly status : "not-approved"; readonly alternatives : readonly string[] }
-    | { readonly status : "unknown" };
-
-export const DICTIONARY_FORMAT = "ste-lint-dictionary";
-
-/** An error in a dictionary file. */
-export class DictionaryError extends Error {
-    override readonly name : string = "DictionaryError";
-}
-
-const normalize = (word : string) : string => word.trim().toLowerCase().replace(/[’‘]/g, "'");
-
-/** The approved words of a local dictionary. */
-export class Dictionary {
-    private readonly approved = new Set<string>();
-    private readonly approvedNouns = new Set<string>();
-    private readonly notApproved = new Map<string, readonly string[]>();
-    /** The approved nouns. The noun-cluster rule uses them. */
-    readonly nouns : Set<string> = new Set<string>();
-    /** The approved verbs. The imperative and missing-subject heuristics use them. */
-    readonly verbs : Set<string> = new Set<string>();
-
-    constructor(entries : readonly DictionaryEntry[]) {
-        for (const entry of entries) {
-            const words = [entry.word, ...(entry.forms ?? [])].flatMap((form) => normalize(form).split(/\s+/)).filter((form) => form.length > 0);
-            if (entry.approved === false) {
-                for (const word of words) this.notApproved.set(word, entry.alternatives ?? []);
-                continue;
-            }
-            for (const word of words) this.approved.add(word);
-            const pos = (entry.pos ?? "").toLowerCase();
-            const base = normalize(entry.word);
-            if (pos === "n" || pos === "noun") {
-                this.approvedNouns.add(base);
-                this.nouns.add(base);
-            }
-            if (pos === "v" || pos === "verb") this.verbs.add(base);
-        }
-    }
-
-    /** The number of approved words and forms. */
-    get size() : number {
-        return this.approved.size;
-    }
-
-    /** The status of `word` in the dictionary. */
-    lookup(word : string) : DictionaryLookup {
-        const lower = normalize(word);
-        const candidates = [lower];
-        if (lower.endsWith("'s")) candidates.push(lower.slice(0, -2));
-        for (const candidate of candidates) {
-            if (this.approved.has(candidate)) return { status : "approved" };
-            const plurals = [candidate.slice(0, -1), candidate.slice(0, -2), candidate.slice(0, -3) + "y"];
-            if (candidate.endsWith("s") && plurals.some((singular) => this.approvedNouns.has(singular))) return { status : "approved" };
-        }
-        for (const candidate of candidates) {
-            const alternatives = this.notApproved.get(candidate);
-            if (alternatives !== undefined) return { status : "not-approved", alternatives };
-        }
-        return { status : "unknown" };
-    }
-}
-
-/** This function makes a dictionary from parsed JSON. `source` is the file name for error messages. */
-export function parseDictionary(value : unknown, source : string) : Dictionary {
-    if (Array.isArray(value)) {
-        if (!value.every((word) => typeof word === "string")) {
-            throw new DictionaryError(`${source}: the array form must contain only strings.`);
-        }
-        return new Dictionary(value.map((word : string) => ({ word })));
-    }
-    if (typeof value !== "object" || value === null) {
-        throw new DictionaryError(`${source}: the file must contain an array of words or an object with "entries".`);
-    }
-    const record = value as Record<string, unknown>;
-    const format = record["format"];
-    if (format !== undefined && format !== DICTIONARY_FORMAT) {
-        throw new DictionaryError(`${source}: "format" must be "${DICTIONARY_FORMAT}".`);
-    }
-    const entries = record["entries"];
-    if (!Array.isArray(entries)) throw new DictionaryError(`${source}: "entries" must be an array.`);
-    const parsed : DictionaryEntry[] = entries.map((entry : unknown, index : number) => parseEntry(entry, `${source}: entries[${index}]`));
-    return new Dictionary(parsed);
-}
-
-function stringArray(value : unknown, where : string) : string[] | undefined {
-    if (value === undefined) return undefined;
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
-        throw new DictionaryError(`${where} must be an array of strings.`);
-    }
-    return value as string[];
-}
-
-function parseEntry(entry : unknown, where : string) : DictionaryEntry {
-    if (typeof entry === "string") return { word : entry };
-    if (typeof entry !== "object" || entry === null) throw new DictionaryError(`${where} must be a string or an object.`);
-    const record = entry as Record<string, unknown>;
-    const word = record["word"];
-    if (typeof word !== "string" || word.trim().length === 0) throw new DictionaryError(`${where}.word must be a string that is not empty.`);
-    const pos = record["pos"];
-    if (pos !== undefined && typeof pos !== "string") throw new DictionaryError(`${where}.pos must be a string.`);
-    const approved = record["approved"];
-    if (approved !== undefined && typeof approved !== "boolean") throw new DictionaryError(`${where}.approved must be true or false.`);
-    const forms = stringArray(record["forms"], `${where}.forms`);
-    const alternatives = stringArray(record["alternatives"], `${where}.alternatives`);
-    return {
-        word,
-        ...(pos === undefined ? {} : { pos }),
-        ...(approved === undefined ? {} : { approved }),
-        ...(forms === undefined ? {} : { forms }),
-        ...(alternatives === undefined ? {} : { alternatives }),
-    };
-}
+export * from "./dictionary-core.js";
 
 /** This function reads a dictionary file. */
 export function loadDictionary(path : string) : Dictionary {

package/src/engine.ts

@@ -0,0 +1,138 @@
+/**
+ * The lint engine without a file system. It extracts the prose of a text,
+ * runs the rules on each prose unit, and gives the findings with their lines
+ * and columns. A browser can use this module.
+ */
+
+import type { ResolvedConfig } from "./config-core.js";
+import { buildLexicon, type Lexicon } from "./lexicon.js";
+import { RULES, type Rule } from "./rules/index.js";
+import { WordListMatcher } from "./rules/word-list-matcher.js";
+import { LineIndex } from "./source/lines.js";
+import { extractMarkdown, type Extraction } from "./source/markdown.js";
+import { isSuppressed } from "./source/suppressions.js";
+import type { Finding, RuleId, Severity } from "./types.js";
+import { buildUnit, type ProseUnit } from "./units.js";
+
+export type FileKind = "markdown" | "mdx" | "typescript";
+
+/** The kind of a file, from its extension, or null when the linter cannot read it. */
+export function fileKind(path : string) : FileKind | null {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".mdx")) return "mdx";
+    if (lower.endsWith(".md") || lower.endsWith(".markdown")) return "markdown";
+    if (/\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/.test(lower) && !lower.endsWith(".d.ts")) return "typescript";
+    return null;
+}
+
+/**
+ * A function that extracts the prose of a TypeScript or JavaScript file:
+ * the doc comments, and the JSX text of a TSX or JSX file.
+ */
+export type CodeExtractor = (text : string, path : string) => Extraction;
+
+export type ProseLinterOptions = {
+    /**
+     * The extractor for TypeScript and JavaScript files. Without it, the
+     * linter gives no findings for these files. The extractor of this
+     * package (`extractCode`) needs the `typescript` package.
+     */
+    readonly extractCode? : CodeExtractor;
+};
+
+/**
+ * A linter for one configuration, for text in memory. It makes the lexicon
+ * and the word list matcher one time. It reads no file.
+ */
+export class ProseLinter {
+    readonly lexicon : Lexicon;
+    private readonly wordList : WordListMatcher;
+    private readonly rules : ReadonlyArray<{ readonly rule : Rule; readonly override : Severity | null }>;
+    private readonly extractCode : CodeExtractor | null;
+
+    constructor(readonly config : ResolvedConfig, lexicon? : Lexicon, options : ProseLinterOptions = {}) {
+        this.lexicon = lexicon ?? buildLexicon(config);
+        this.wordList = new WordListMatcher(config.wordList);
+        this.extractCode = options.extractCode ?? null;
+        this.rules = RULES.flatMap((rule) => {
+            const setting = config.rules[rule.id];
+            if (setting === "off") return [];
+            if (rule.id === "unknown-word" && this.lexicon.dictionary === null) return [];
+            return [{ rule, override : setting ?? null }];
+        });
+    }
+
+    /** The prose units of a file. */
+    units(text : string, path : string) : ProseUnit[] {
+        return this.extract(text, path).blocks.flatMap((block) => buildUnit(block, this.lexicon) ?? []);
+    }
+
+    /** The findings in `text`. `path` gives the kind of file, and it is the file name in the findings. */
+    lintText(text : string, path : string) : Finding[] {
+        const extraction = this.extract(text, path);
+        const lineIndex = new LineIndex(text);
+        type Raw = { ruleId : RuleId; severity : Severity; start : number; end : number; message : string; eachWord : boolean };
+        const raw : Raw[] = [];
+        for (const block of extraction.blocks) {
+            const unit = buildUnit(block, this.lexicon);
+            if (unit === null) continue;
+            const wordOnly = unit.kind !== "paragraph";
+            for (const { rule, override } of this.rules) {
+                if (wordOnly && rule.scope !== "word") continue;
+                rule.check(unit, {
+                    config : this.config,
+                    lexicon : this.lexicon,
+                    wordList : this.wordList,
+                    report : (report) => {
+                        raw.push({
+                            ruleId : rule.id,
+                            severity : override ?? report.severity ?? rule.defaultSeverity,
+                            start : report.start,
+                            end : report.end,
+                            message : report.message,
+                            eachWord : reportsEachWord(rule),
+                        });
+                    },
+                });
+            }
+        }
+        // An unknown word that another rule reports already gets no second finding. A finding for a
+        // sentence, a paragraph or a noun cluster does not report each word in it.
+        const others = raw.filter((finding) => finding.ruleId !== "unknown-word" && finding.eachWord);
+        const kept = raw.filter((finding) => finding.ruleId !== "unknown-word"
+            || !others.some((other) => other.start < finding.end && finding.start < other.end));
+        return kept
+            .filter((finding) => !isSuppressed(extraction.suppressions, finding.ruleId, finding.start))
+            .sort((a, b) => a.start - b.start || a.end - b.end || a.ruleId.localeCompare(b.ruleId))
+            .map((finding) => {
+                const start = lineIndex.position(finding.start);
+                const end = lineIndex.position(Math.max(finding.start, finding.end));
+                return {
+                    file : path,
+                    line : start.line,
+                    column : start.column,
+                    endLine : end.line,
+                    endColumn : end.column,
+                    ruleId : finding.ruleId,
+                    severity : finding.severity,
+                    message : finding.message,
+                };
+            });
+    }
+
+    private extract(text : string, path : string) : Extraction {
+        const kind = fileKind(path);
+        if (kind === "typescript") return this.extractCode === null ? { blocks : [], suppressions : [] } : this.extractCode(text, path);
+        if (kind === null) return { blocks : [], suppressions : [] };
+        return extractMarkdown(text, { mdx : kind === "mdx" });
+    }
+}
+
+/**
+ * True when a finding of the rule is about each word in its range. A word rule reports a word or a
+ * phrase, for example a modal verb or a word list phrase. The noun-cluster rule reports a group of
+ * nouns, and the sentence and paragraph rules report a full sentence or paragraph.
+ */
+function reportsEachWord(rule : Rule) : boolean {
+    return rule.scope === "word" && rule.id !== "noun-cluster";
+}

package/src/index.ts

@@ -6,6 +6,7 @@
  */
 
 export {
+    baseConfig,
     CONFIG_FILE_NAME,
     ConfigError,
     DEFAULT_IGNORE,
@@ -17,6 +18,7 @@ export {
     mergeWordList,
     resolveConfig,
     validateConfig,
+    type BaseConfigOptions,
     type Limits,
     type LimitsConfig,
     type ResolvedConfig,
@@ -27,7 +29,9 @@ export { Dictionary, DICTIONARY_FORMAT, DictionaryError, loadDictionary, parseDi
 export { findFiles, globToRegExp } from "./files.js";
 export { formatJson, formatText, summarize, type RuleCount, type Summary } from "./format.js";
 export { buildLexicon, type Lexicon } from "./lexicon.js";
+export { ProseLinter, type CodeExtractor, type ProseLinterOptions } from "./engine.js";
 export { fileKind, Linter, lintText, type FileKind } from "./lint.js";
+export { extractCode } from "./source/code.js";
 export { getRule, RULES, type Rule } from "./rules/index.js";
 export { parseArgs, runCli, USAGE, type CliIo, type CliOptions } from "./run-cli.js";
 export { isRuleId, RULE_IDS, type Finding, type RuleId, type RuleSetting, type Severity } from "./types.js";

package/src/lint.ts

@@ -1,105 +1,21 @@
 /**
- * The lint engine. It extracts the prose of a file, runs the rules on each
- * prose unit, and gives the findings with their lines and columns.
+ * The linter for files: the engine of `engine.ts`, with the extractor of
+ * TypeScript doc comments and the file system.
  */
 
 import { readFileSync } from "node:fs";
 import type { ResolvedConfig } from "./config.js";
-import { buildLexicon, type Lexicon } from "./lexicon.js";
-import { RULES, type Rule } from "./rules/index.js";
-import { WordListMatcher } from "./rules/word-list-matcher.js";
-import { LineIndex } from "./source/lines.js";
-import { extractMarkdown, type Extraction } from "./source/markdown.js";
-import { isSuppressed } from "./source/suppressions.js";
-import { extractTsdoc } from "./source/tsdoc.js";
-import { extractJsxText } from "./source/jsx.js";
-import type { Finding, RuleId, Severity } from "./types.js";
-import { buildUnit, type ProseUnit } from "./units.js";
+import { ProseLinter } from "./engine.js";
+import type { Lexicon } from "./lexicon.js";
+import { extractCode } from "./source/code.js";
+import type { Finding } from "./types.js";
 
-export type FileKind = "markdown" | "mdx" | "typescript";
-
-/** The kind of a file, from its extension, or null when the linter cannot read it. */
-export function fileKind(path : string) : FileKind | null {
-    const lower = path.toLowerCase();
-    if (lower.endsWith(".mdx")) return "mdx";
-    if (lower.endsWith(".md") || lower.endsWith(".markdown")) return "markdown";
-    if (/\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/.test(lower) && !lower.endsWith(".d.ts")) return "typescript";
-    return null;
-}
+export { fileKind, type FileKind } from "./engine.js";
 
 /** A linter for one configuration. It makes the lexicon and the word list matcher one time. */
-export class Linter {
-    readonly lexicon : Lexicon;
-    private readonly wordList : WordListMatcher;
-    private readonly rules : ReadonlyArray<{ readonly rule : Rule; readonly override : Severity | null }>;
-
-    constructor(readonly config : ResolvedConfig, lexicon? : Lexicon) {
-        this.lexicon = lexicon ?? buildLexicon(config);
-        this.wordList = new WordListMatcher(config.wordList);
-        this.rules = RULES.flatMap((rule) => {
-            const setting = config.rules[rule.id];
-            if (setting === "off") return [];
-            if (rule.id === "unknown-word" && this.lexicon.dictionary === null) return [];
-            return [{ rule, override : setting ?? null }];
-        });
-    }
-
-    /** The prose units of a file. */
-    units(text : string, path : string) : ProseUnit[] {
-        return extract(text, path).blocks.flatMap((block) => buildUnit(block, this.lexicon) ?? []);
-    }
-
-    /** The findings in `text`. `path` gives the kind of file, and it is the file name in the findings. */
-    lintText(text : string, path : string) : Finding[] {
-        const extraction = extract(text, path);
-        const lineIndex = new LineIndex(text);
-        type Raw = { ruleId : RuleId; severity : Severity; start : number; end : number; message : string; eachWord : boolean };
-        const raw : Raw[] = [];
-        for (const block of extraction.blocks) {
-            const unit = buildUnit(block, this.lexicon);
-            if (unit === null) continue;
-            const wordOnly = unit.kind !== "paragraph";
-            for (const { rule, override } of this.rules) {
-                if (wordOnly && rule.scope !== "word") continue;
-                rule.check(unit, {
-                    config : this.config,
-                    lexicon : this.lexicon,
-                    wordList : this.wordList,
-                    report : (report) => {
-                        raw.push({
-                            ruleId : rule.id,
-                            severity : override ?? report.severity ?? rule.defaultSeverity,
-                            start : report.start,
-                            end : report.end,
-                            message : report.message,
-                            eachWord : reportsEachWord(rule),
-                        });
-                    },
-                });
-            }
-        }
-        // An unknown word that another rule reports already gets no second finding. A finding for a
-        // sentence, a paragraph or a noun cluster does not report each word in it.
-        const others = raw.filter((finding) => finding.ruleId !== "unknown-word" && finding.eachWord);
-        const kept = raw.filter((finding) => finding.ruleId !== "unknown-word"
-            || !others.some((other) => other.start < finding.end && finding.start < other.end));
-        return kept
-            .filter((finding) => !isSuppressed(extraction.suppressions, finding.ruleId, finding.start))
-            .sort((a, b) => a.start - b.start || a.end - b.end || a.ruleId.localeCompare(b.ruleId))
-            .map((finding) => {
-                const start = lineIndex.position(finding.start);
-                const end = lineIndex.position(Math.max(finding.start, finding.end));
-                return {
-                    file : path,
-                    line : start.line,
-                    column : start.column,
-                    endLine : end.line,
-                    endColumn : end.column,
-                    ruleId : finding.ruleId,
-                    severity : finding.severity,
-                    message : finding.message,
-                };
-            });
+export class Linter extends ProseLinter {
+    constructor(config : ResolvedConfig, lexicon? : Lexicon) {
+        super(config, lexicon, { extractCode });
     }
 
     /** The findings in a file on disk. `displayPath` is the file name in the findings. */
@@ -108,27 +24,6 @@ export class Linter {
     }
 }
 
-/**
- * True when a finding of the rule is about each word in its range. A word rule reports a word or a
- * phrase, for example a modal verb or a word list phrase. The noun-cluster rule reports a group of
- * nouns, and the sentence and paragraph rules report a full sentence or paragraph.
- */
-function reportsEachWord(rule : Rule) : boolean {
-    return rule.scope === "word" && rule.id !== "noun-cluster";
-}
-
-function extract(text : string, path : string) : Extraction {
-    const kind = fileKind(path);
-    if (kind === "typescript") {
-        const comments = extractTsdoc(text, path);
-        if (!/\.[jt]sx$/i.test(path)) return comments;
-        // The text that the user interface shows
-        return { blocks : [...comments.blocks, ...extractJsxText(text, path).blocks], suppressions : comments.suppressions };
-    }
-    if (kind === null) return { blocks : [], suppressions : [] };
-    return extractMarkdown(text, { mdx : kind === "mdx" });
-}
-
 /** The findings in `text`, with a new linter. To lint many files, make one `Linter` and use it again. */
 export function lintText(text : string, path : string, config : ResolvedConfig, lexicon? : Lexicon) : Finding[] {
     return new Linter(config, lexicon).lintText(text, path);

package/src/source/code.ts

@@ -0,0 +1,17 @@
+/**
+ * The prose of a TypeScript or JavaScript file: the doc comments, and the
+ * text that the JSX of a TSX or JSX file shows. This module needs the
+ * `typescript` package, but no file system. A browser can use it.
+ */
+
+import { extractJsxText } from "./jsx.js";
+import type { Extraction } from "./markdown.js";
+import { extractTsdoc } from "./tsdoc.js";
+
+/** This function extracts the prose of the source text of a TypeScript or JavaScript file. `path` gives the kind of file. */
+export function extractCode(text : string, path : string) : Extraction {
+    const comments = extractTsdoc(text, path);
+    if (!/\.[jt]sx$/i.test(path)) return comments;
+    // The text that the user interface shows
+    return { blocks : [...comments.blocks, ...extractJsxText(text, path).blocks], suppressions : comments.suppressions };
+}