@mark1russell7/ste-lint 0.0.0-stage → 0.1.1

package/dist/text/tokens.d.ts

@@ -0,0 +1,35 @@
+import { type InlineText, type Placeholder } from "../source/inline.js";
+export type TokenKind = "word" | "code" | "punct";
+export type Token = {
+    readonly kind: TokenKind;
+    /** The surface text. For a placeholder, the text in the code span, link tag or quote. */
+    readonly text: string;
+    /** The text in lower case, with typographic apostrophes changed to `'`. */
+    readonly lower: string;
+    /** The file offset of the first character. */
+    readonly start: number;
+    /** The file offset after the last character. */
+    readonly end: number;
+    /** True when white space comes before the token in the clean text. */
+    readonly spaceBefore: boolean;
+    readonly placeholder: Placeholder | null;
+};
+/** This function divides clean text into word, code and punctuation tokens. */
+export declare function tokenize(inline: InlineText): Token[];
+/** The lower-case form of a word, with typographic apostrophes changed to `'`. */
+export declare function normalizeWord(text: string): string;
+export declare function isWord(token: Token | undefined): token is Token;
+/** True for a word or a placeholder. Both count in the STE word count. */
+export declare function isCounted(token: Token | undefined): boolean;
+export declare function isNumber(token: Token | undefined): boolean;
+/** True for an abbreviation in capital letters, for example `API`, `CPUs` or `HTTP2`. */
+export declare function isAbbreviation(token: Token | undefined): boolean;
+/** True when the first character is a capital letter. */
+export declare function isCapitalized(token: Token | undefined): boolean;
+/**
+ * True for a word that looks like code although it is not in code font.
+ * Examples are a camelCase or snake_case name, a path with dots or slashes,
+ * a flag, a word with digits, and a name with `()`.
+ */
+export declare function isIdentifierLike(token: Token | undefined): boolean;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/text/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/text/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGrF,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAElD,MAAM,MAAM,KAAK,GAAG;IAChB,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAC;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAG,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAG,OAAO,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAG,WAAW,GAAG,IAAI,CAAC;CAC7C,CAAC;AAaF,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,MAAM,EAAG,UAAU,GAAI,KAAK,EAAE,CAyDtD;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,IAAI,EAAG,MAAM,GAAI,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,KAAK,IAAI,KAAK,CAEjE;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,OAAO,CAE7D;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,OAAO,CAE5D;AAED,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,OAAO,CAElE;AAED,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,OAAO,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAG,KAAK,GAAG,SAAS,GAAI,OAAO,CAUpE"}

package/dist/text/tokens.js

@@ -0,0 +1,113 @@
+import { PLACEHOLDER } from "../source/inline.js";
+import { NUMBER_WORDS } from "./words.js";
+/**
+ * One word: letters and digits, with hyphens, dots, slashes, underscores,
+ * colons and apostrophes inside it. Thus `main-thread`, `I/O`, `e.g`,
+ * `v1.2.3`, `snake_case`, `don't`, `1,000` and `packages/lag` are each one word. A
+ * word can start with `--`, `-`, `@`, `#` or `$` (flags, scoped packages,
+ * issue numbers, variables), and it can end with `()`.
+ */
+const WORD = /(?:--?|[@#$])?[\p{L}\p{N}][\p{L}\p{N}\p{M}]*(?:(?:['’](?=\p{L})|[-_./:+@#\\](?=[\p{L}\p{N}])|(?<=\p{N})–(?=\p{N})|(?<=\p{N}),(?=\p{N}{3}(?!\p{N})))[\p{L}\p{N}\p{M}]*)*(?:\(\))?/uy;
+const CHAR = /./suy;
+/** This function divides clean text into word, code and punctuation tokens. */
+export function tokenize(inline) {
+    const { clean, offsets, placeholders } = inline;
+    const tokens = [];
+    let i = 0;
+    let space = true;
+    while (i < clean.length) {
+        const char = clean[i];
+        if (/\s/.test(char)) {
+            space = true;
+            i++;
+            continue;
+        }
+        if (char === PLACEHOLDER) {
+            const placeholder = placeholders.get(i);
+            if (placeholder !== undefined) {
+                tokens.push({
+                    kind: "code",
+                    text: placeholder.text,
+                    lower: normalizeWord(placeholder.text),
+                    start: placeholder.start,
+                    end: placeholder.end,
+                    spaceBefore: space,
+                    placeholder,
+                });
+                space = false;
+                i++;
+                continue;
+            }
+        }
+        WORD.lastIndex = i;
+        const word = WORD.exec(clean);
+        let text;
+        let kind;
+        if (word !== null) {
+            text = word[0];
+            kind = "word";
+        }
+        else if (clean.startsWith("...", i)) {
+            text = "...";
+            kind = "punct";
+        }
+        else {
+            CHAR.lastIndex = i;
+            text = CHAR.exec(clean)[0];
+            kind = "punct";
+        }
+        tokens.push({
+            kind,
+            text,
+            lower: normalizeWord(text),
+            start: offsets[i],
+            end: offsets[i + text.length - 1] + 1,
+            spaceBefore: space,
+            placeholder: null,
+        });
+        space = false;
+        i += text.length;
+    }
+    return tokens;
+}
+/** The lower-case form of a word, with typographic apostrophes changed to `'`. */
+export function normalizeWord(text) {
+    return text.toLowerCase().replace(/[’‘]/g, "'");
+}
+export function isWord(token) {
+    return token !== undefined && token.kind === "word";
+}
+/** True for a word or a placeholder. Both count in the STE word count. */
+export function isCounted(token) {
+    return token !== undefined && token.kind !== "punct";
+}
+export function isNumber(token) {
+    return isWord(token) && (/^[-+]?\d[\d,.–-]*%?$/.test(token.text) || NUMBER_WORDS.has(token.lower));
+}
+/** True for an abbreviation in capital letters, for example `API`, `CPUs` or `HTTP2`. */
+export function isAbbreviation(token) {
+    return isWord(token) && /^[A-Z][A-Z0-9]+s?$/.test(token.text) && /[A-Z].*[A-Z]|^[A-Z][0-9]/.test(token.text);
+}
+/** True when the first character is a capital letter. */
+export function isCapitalized(token) {
+    return isWord(token) && /^\p{Lu}/u.test(token.text);
+}
+/**
+ * True for a word that looks like code although it is not in code font.
+ * Examples are a camelCase or snake_case name, a path with dots or slashes,
+ * a flag, a word with digits, and a name with `()`.
+ */
+export function isIdentifierLike(token) {
+    if (!isWord(token))
+        return false;
+    const text = token.text;
+    if (/^(?:e\.g|i\.e|u\.s|a\.m|p\.m)$/i.test(text))
+        return false;
+    return /\p{Ll}\p{Lu}/u.test(text)
+        || /\p{Lu}{2,}\p{Ll}/u.test(text)
+        || /[_./\\:@#$]/.test(text)
+        || /^--?/.test(text)
+        || text.endsWith("()")
+        || (/\d/.test(text) && /\p{L}/u.test(text));
+}
+//# sourceMappingURL=tokens.js.map

package/dist/text/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../src/text/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAqC,MAAM,qBAAqB,CAAC;AACrF,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAmB1C;;;;;;GAMG;AACH,MAAM,IAAI,GAAG,oLAAoL,CAAC;AAElM,MAAM,IAAI,GAAG,MAAM,CAAC;AAEpB,+EAA+E;AAC/E,MAAM,UAAU,QAAQ,CAAC,MAAmB;IACxC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IAChD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,KAAK,GAAG,IAAI,CAAC;IACjB,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QACvB,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAClB,KAAK,GAAG,IAAI,CAAC;YACb,CAAC,EAAE,CAAC;YACJ,SAAS;QACb,CAAC;QACD,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACvB,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;gBAC5B,MAAM,CAAC,IAAI,CAAC;oBACR,IAAI,EAAG,MAAM;oBACb,IAAI,EAAG,WAAW,CAAC,IAAI;oBACvB,KAAK,EAAG,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC;oBACvC,KAAK,EAAG,WAAW,CAAC,KAAK;oBACzB,GAAG,EAAG,WAAW,CAAC,GAAG;oBACrB,WAAW,EAAG,KAAK;oBACnB,WAAW;iBACd,CAAC,CAAC;gBACH,KAAK,GAAG,KAAK,CAAC;gBACd,CAAC,EAAE,CAAC;gBACJ,SAAS;YACb,CAAC;QACL,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,IAAa,CAAC;QAClB,IAAI,IAAgB,CAAC;QACrB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChB,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,IAAI,GAAG,MAAM,CAAC;QAClB,CAAC;aAAM,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YACpC,IAAI,GAAG,KAAK,CAAC;YACb,IAAI,GAAG,OAAO,CAAC;QACnB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;YACnB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAE,CAAC,CAAC,CAAC,CAAC;YAC5B,IAAI,GAAG,OAAO,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,IAAI,CAAC;YACR,IAAI;YACJ,IAAI;YACJ,KAAK,EAAG,aAAa,CAAC,IAAI,CAAC;YAC3B,KAAK,EAAG,OAAO,CAAC,CAAC,CAAE;YACnB,GAAG,EAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,GAAG,CAAC;YACvC,WAAW,EAAG,KAAK;YACnB,WAAW,EAAG,IAAI;SACrB,CAAC,CAAC;QACH,KAAK,GAAG,KAAK,CAAC;QACd,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,aAAa,CAAC,IAAa;IACvC,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAyB;IAC5C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;AACxD,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,SAAS,CAAC,KAAyB;IAC/C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAyB;IAC9C,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACvG,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,cAAc,CAAC,KAAyB;IACpD,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACjH,CAAC;AAED,yDAAyD;AACzD,MAAM,UAAU,aAAa,CAAC,KAAyB;IACnD,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAyB;IACtD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACjC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACxB,IAAI,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/D,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;WAC1B,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC;WAC9B,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;WACxB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;WACjB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;WACnB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AACpD,CAAC"}

package/dist/text/words.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Closed word classes and short word lists for the grammar heuristics.
+ *
+ * These lists are general English grammar. They do not come from the
+ * ASD-STE100 dictionary. The linter cannot tag parts of speech, so the
+ * heuristics look at the words near a word to guess how the text uses it.
+ */
+export declare const DETERMINERS: ReadonlySet<string>;
+export declare const SUBJECT_PRONOUNS: ReadonlySet<string>;
+export declare const OBJECT_PRONOUNS: ReadonlySet<string>;
+/** Forms of "be", with the contractions that contain "is", "are" or "am". */
+export declare const BE_FORMS: ReadonlySet<string>;
+/** Words before a past participle that make a passive: forms of "be" and "get". */
+export declare const PASSIVE_AUXILIARIES: ReadonlySet<string>;
+export declare const HAVE_FORMS: ReadonlySet<string>;
+export declare const DO_FORMS: ReadonlySet<string>;
+export declare const MODALS: ReadonlySet<string>;
+export declare const PREPOSITIONS: ReadonlySet<string>;
+export declare const CONJUNCTIONS: ReadonlySet<string>;
+/** Words that start a condition or purpose clause before the main clause. */
+export declare const CLAUSE_STARTERS: ReadonlySet<string>;
+/** Words that can come before the verb of an imperative sentence. */
+export declare const LEADING_ADVERBS: ReadonlySet<string>;
+/** Adverbs that can come between an auxiliary verb and a participle. */
+export declare const MIDDLE_ADVERBS: ReadonlySet<string>;
+/** Words that tell the reader that a clause is a condition, so a participle after "be" is a state. */
+export declare const CONDITION_MARKERS: ReadonlySet<string>;
+export declare const PARTICLES: ReadonlySet<string>;
+export declare const NUMBER_WORDS: ReadonlySet<string>;
+/** Units of measurement. A number and its unit count as one word (STE Rule 8.6). */
+export declare const UNITS: ReadonlySet<string>;
+/**
+ * Words that end in "-ing" but are usually not verb forms: nouns, adjectives,
+ * prepositions, and base forms, for example "bring".
+ */
+export declare const NON_VERB_ING: ReadonlySet<string>;
+/** Irregular past participles. A participle after "be" makes a passive. */
+export declare const IRREGULAR_PARTICIPLES: ReadonlySet<string>;
+/** Words that end in "-ed" but are not past participles. */
+export declare const NOT_PARTICIPLE_ED: ReadonlySet<string>;
+/**
+ * Common verbs in their base form. The imperative heuristic and the
+ * missing-subject heuristic use this list. The project glossary adds
+ * technical verbs to it.
+ */
+export declare const COMMON_VERBS: ReadonlySet<string>;
+/**
+ * Nouns that software text often uses before another noun. The noun-cluster
+ * heuristic counts only these words, technical nouns, proper nouns,
+ * abbreviations and code. Words that are frequently verbs are not in this
+ * list, so the heuristic does not count a verb as a noun.
+ */
+export declare const COMMON_NOUNS: ReadonlySet<string>;
+/** Abbreviations after which a period does not end a sentence. */
+export declare const NO_BREAK_ABBREVIATIONS: ReadonlySet<string>;
+/** Abbreviations that do not end a sentence when a number comes after them, for example "Fig. 3". */
+export declare const NUMBER_ABBREVIATIONS: ReadonlySet<string>;
+//# sourceMappingURL=words.d.ts.map

package/dist/text/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../../src/text/words.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,WAAW,EAAG,WAAW,CAAC,MAAM,CAG3C,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAG,WAAW,CAAC,MAAM,CAA4D,CAAC;AAE/G,eAAO,MAAM,eAAe,EAAG,WAAW,CAAC,MAAM,CAAuE,CAAC;AAEzH,6EAA6E;AAC7E,eAAO,MAAM,QAAQ,EAAG,WAAW,CAAC,MAAM,CAGxC,CAAC;AAEH,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,EAAG,WAAW,CAAC,MAAM,CAAqE,CAAC;AAE3H,eAAO,MAAM,UAAU,EAAG,WAAW,CAAC,MAAM,CAAoD,CAAC;AAEjG,eAAO,MAAM,QAAQ,EAAG,WAAW,CAAC,MAAM,CAA2C,CAAC;AAEtF,eAAO,MAAM,MAAM,EAAG,WAAW,CAAC,MAAM,CAEtC,CAAC;AAEH,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAI5C,CAAC;AAEH,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAE5C,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,eAAe,EAAG,WAAW,CAAC,MAAM,CAG/C,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,eAAe,EAAG,WAAW,CAAC,MAAM,CAG/C,CAAC;AAEH,wEAAwE;AACxE,eAAO,MAAM,cAAc,EAAG,WAAW,CAAC,MAAM,CAI9C,CAAC;AAEH,sGAAsG;AACtG,eAAO,MAAM,iBAAiB,EAAG,WAAW,CAAC,MAAM,CAEjD,CAAC;AAEH,eAAO,MAAM,SAAS,EAAG,WAAW,CAAC,MAAM,CAAyC,CAAC;AAErF,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAI5C,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,KAAK,EAAG,WAAW,CAAC,MAAM,CAMrC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAS5C,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,EAAG,WAAW,CAAC,MAAM,CAQrD,CAAC;AAEH,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,EAAG,WAAW,CAAC,MAAM,CAGjD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAuB5C,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAG,WAAW,CAAC,MAAM,CAmB5C,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,EAAG,WAAW,CAAC,MAAM,CAEtD,CAAC;AAEH,qGAAqG;AACrG,eAAO,MAAM,oBAAoB,EAAG,WAAW,CAAC,MAAM,CAA0D,CAAC"}

package/dist/text/words.js

@@ -0,0 +1,159 @@
+/**
+ * Closed word classes and short word lists for the grammar heuristics.
+ *
+ * These lists are general English grammar. They do not come from the
+ * ASD-STE100 dictionary. The linter cannot tag parts of speech, so the
+ * heuristics look at the words near a word to guess how the text uses it.
+ */
+const set = (words) => new Set(words.trim().split(/\s+/));
+export const DETERMINERS = set(`
+    a an the this that these those each every all any some no its their your our my his her
+    another other either neither both many much more most few several such which whose what one
+`);
+export const SUBJECT_PRONOUNS = set("i you we they he she it this that which who there");
+export const OBJECT_PRONOUNS = set("me you us them him her it itself themselves this these those");
+/** Forms of "be", with the contractions that contain "is", "are" or "am". */
+export const BE_FORMS = set(`
+    am is are was were be been being isn't aren't wasn't weren't it's that's there's here's what's who's
+    he's she's they're we're you're i'm
+`);
+/** Words before a past participle that make a passive: forms of "be" and "get". */
+export const PASSIVE_AUXILIARIES = new Set([...BE_FORMS, "get", "gets", "got", "gotten", "getting"]);
+export const HAVE_FORMS = set("have has had having haven't hasn't hadn't");
+export const DO_FORMS = set("do does did don't doesn't didn't");
+export const MODALS = set(`
+    can cannot could may might must shall should will would can't couldn't mustn't shouldn't won't wouldn't
+`);
+export const PREPOSITIONS = set(`
+    about above across after against along among around as at before behind below beneath beside between
+    beyond by despite down during except for from in inside into like near of off on onto out outside over
+    past per since through throughout to toward towards under until up upon via with within without
+`);
+export const CONJUNCTIONS = set(`
+    and or but nor so yet if when while because although though unless until whether that where once than
+`);
+/** Words that start a condition or purpose clause before the main clause. */
+export const CLAUSE_STARTERS = set(`
+    if when whenever before after while until unless once to for in on at during because as since where
+    with without by from although though
+`);
+/** Words that can come before the verb of an imperative sentence. */
+export const LEADING_ADVERBS = set(`
+    then first next also finally optionally now please second third afterward afterwards alternatively
+    instead always only just simply again manually carefully immediately
+`);
+/** Adverbs that can come between an auxiliary verb and a participle. */
+export const MIDDLE_ADVERBS = set(`
+    not also always never only then still already often usually automatically immediately sometimes just
+    all both each first again correctly currently directly fully later normally now once possibly
+    probably quickly rarely really safely silently simply successfully typically
+`);
+/** Words that tell the reader that a clause is a condition, so a participle after "be" is a state. */
+export const CONDITION_MARKERS = set(`
+    if when whenever until unless while after before once whether sure that because since
+`);
+export const PARTICLES = set("up out down off back over away");
+export const NUMBER_WORDS = set(`
+    zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen
+    seventeen eighteen nineteen twenty thirty forty fifty sixty seventy eighty ninety hundred hundreds
+    thousand thousands million millions billion billions dozen dozens half twice
+`);
+/** Units of measurement. A number and its unit count as one word (STE Rule 8.6). */
+export const UNITS = set(`
+    ns µs μs us ms s sec secs second seconds millisecond milliseconds microsecond microseconds nanosecond
+    nanoseconds min mins minute minutes h hr hrs hour hours day days week weeks month months year years
+    b byte bytes kb mb gb tb kib mib gib tib kilobyte kilobytes megabyte megabytes gigabyte gigabytes
+    % percent px pixel pixels hz khz mhz ghz fps °c °f degree degrees kg g mm cm m km kilogram kilograms
+    gram grams kilometer kilometers liter liters litre litres inch inches
+`);
+/**
+ * Words that end in "-ing" but are usually not verb forms: nouns, adjectives,
+ * prepositions, and base forms, for example "bring".
+ */
+export const NON_VERB_ING = set(`
+    thing things string strings ring rings spring springs king kings wing wings sing bring brings during
+    something anything everything nothing morning mornings evening evenings ceiling ceilings sibling
+    siblings duckling earring inkling offspring pudding sterling swing swings sling wring cling fling
+    sting
+    outstanding ongoing upcoming incoming outgoing missing remaining pending interesting confusing
+    misleading surprising promising demanding challenging exciting annoying boring willing worrying
+    overwhelming existing corresponding underlying trailing preceding notwithstanding
+    timing padding heading spacing wording warning beginning opening
+`);
+/** Irregular past participles. A participle after "be" makes a passive. */
+export const IRREGULAR_PARTICIPLES = set(`
+    arisen awoken begun bent bitten blown bound broken brought built bought caught chosen cut dealt done
+    drawn driven eaten fallen fed felt fought found flown forbidden forgotten forgiven frozen gotten given
+    gone grown hung heard hidden hit held hurt kept known laid led left lent let lost made meant met paid
+    put quit read rebuilt reset rerun ridden rung risen run said seen sought sold sent set shaken shown
+    shut sung sunk slept slid spoken spent spun split spread stood stolen stuck struck sworn swept taken
+    taught torn told thought thrown undone understood unset upset withdrawn woken worn won wound written
+    overridden rewritten overwritten bitten
+`);
+/** Words that end in "-ed" but are not past participles. */
+export const NOT_PARTICIPLE_ED = set(`
+    need needed bed red shed feed seed speed bleed breed deed embed exceed proceed succeed indeed hundred
+    kindred sacred naked wicked rugged ragged aged beloved learned
+`);
+/**
+ * Common verbs in their base form. The imperative heuristic and the
+ * missing-subject heuristic use this list. The project glossary adds
+ * technical verbs to it.
+ */
+export const COMMON_VERBS = set(`
+    accept access activate add adjust allow apply assign attach avoid begin bind block break bring build
+    calculate call cancel capture change check choose clean clear click clone close collect combine commit
+    compare compile complete compute configure confirm connect consider contain continue control convert
+    copy correct count cover create deactivate debug decide declare decrease define delay delete deliver
+    depend deploy describe destroy detach detect determine disable disconnect discard dispatch display
+    dispose do download drag drop emit enable end enforce enqueue ensure enter estimate examine exclude
+    execute exit expand expect explain export expose extend extract fail fetch fill filter find finish fire
+    fix flag flush follow force forward freeze generate get give go grant group handle hold ignore implement
+    import include increase indicate initialize insert inspect install invoke keep kill launch leave let
+    limit link list listen load lock log look make manage map mark match measure merge migrate mock modify
+    monitor mount move name navigate need note notify observe obtain omit open operate override parse pass
+    paste pause perform pick pin place point poll post prefer prepare press prevent print process produce
+    provide publish pull push put queue read rebuild reboot receive record reduce refer refresh register
+    reject release reload remember remove rename render repeat replace report request require reschedule
+    reset resize resolve respond restart restore resume retry return reuse review revert rotate run sample
+    save schedule scroll search select send serve set share show shut sign skip sleep sort specify split
+    start stay step stop store submit subscribe substitute supply support swap switch sync take tap tell
+    terminate test throttle throw tick toggle touch track transform trigger try turn type uncomment
+    uninstall unlock unpin unregister unsubscribe update upgrade upload use validate verify view visit wait
+    wake warn watch wrap write yield
+    agree appear arrive ask become belong come differ exist happen help know occur overlap reach remain
+    seem survive think want
+`);
+/**
+ * Nouns that software text often uses before another noun. The noun-cluster
+ * heuristic counts only these words, technical nouns, proper nouns,
+ * abbreviations and code. Words that are frequently verbs are not in this
+ * list, so the heuristic does not count a verb as a noun.
+ */
+export const COMMON_NOUNS = set(`
+    attribute browser buffer bucket byte cache callback channel chart clock collector column component config
+    configuration console constructor container context counter dashboard data database delay dependency
+    deployment device dialog directory document domain duration element endpoint entry environment error
+    event exception exporter factory field file folder frame framework function gauge handler hardware
+    header heap heartbeat histogram history host id identifier index input instance interface interval item
+    key keyboard label latency layer layout length level library lifecycle line listener logger loop
+    machine memory message meter method metric millisecond mode model module monitor mouse network node
+    number object observer offset option origin output owner package page pair parameter parser path
+    pattern payload percentile period permission phase pipeline platform plugin pointer policy pool port
+    position pressure priority problem procedure processor profile program project promise property protocol
+    provider proxy quantity query range rate ratio reader reason receiver recorder reference region registry
+    renderer repository resolution resource response router runtime scheduler schema scope screen script
+    second section selector sender sequence server service session setting signal size slot snapshot socket
+    source span stack stage standard state statement status storage stream string structure style
+    subscriber suite summary symbol syntax system tab table target task template terminal text thread
+    threshold time timeout timer timestamp title token tool topic trace transaction transport tree tuple
+    unit url usage user utility validator value variable vendor version viewport visibility warning window
+    worker workspace wrapper
+`);
+/** Abbreviations after which a period does not end a sentence. */
+export const NO_BREAK_ABBREVIATIONS = set(`
+    e.g i.e vs viz cf al approx mr mrs dr st jr sr inc ltd corp u.s a.m p.m
+`);
+/** Abbreviations that do not end a sentence when a number comes after them, for example "Fig. 3". */
+export const NUMBER_ABBREVIATIONS = set("fig figs eq eqs no nos ref vol ch pp p sec para");
+//# sourceMappingURL=words.js.map

package/dist/text/words.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.js","sourceRoot":"","sources":["../../src/text/words.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,GAAG,GAAG,CAAC,KAAc,EAAwB,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAEzF,MAAM,CAAC,MAAM,WAAW,GAAyB,GAAG,CAAC;;;CAGpD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAyB,GAAG,CAAC,mDAAmD,CAAC,CAAC;AAE/G,MAAM,CAAC,MAAM,eAAe,GAAyB,GAAG,CAAC,8DAA8D,CAAC,CAAC;AAEzH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,QAAQ,GAAyB,GAAG,CAAC;;;CAGjD,CAAC,CAAC;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,mBAAmB,GAAyB,IAAI,GAAG,CAAC,CAAC,GAAG,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAE3H,MAAM,CAAC,MAAM,UAAU,GAAyB,GAAG,CAAC,2CAA2C,CAAC,CAAC;AAEjG,MAAM,CAAC,MAAM,QAAQ,GAAyB,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAEtF,MAAM,CAAC,MAAM,MAAM,GAAyB,GAAG,CAAC;;CAE/C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;;;CAIrD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;CAErD,CAAC,CAAC;AAEH,6EAA6E;AAC7E,MAAM,CAAC,MAAM,eAAe,GAAyB,GAAG,CAAC;;;CAGxD,CAAC,CAAC;AAEH,qEAAqE;AACrE,MAAM,CAAC,MAAM,eAAe,GAAyB,GAAG,CAAC;;;CAGxD,CAAC,CAAC;AAEH,wEAAwE;AACxE,MAAM,CAAC,MAAM,cAAc,GAAyB,GAAG,CAAC;;;;CAIvD,CAAC,CAAC;AAEH,sGAAsG;AACtG,MAAM,CAAC,MAAM,iBAAiB,GAAyB,GAAG,CAAC;;CAE1D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAyB,GAAG,CAAC,gCAAgC,CAAC,CAAC;AAErF,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;;;CAIrD,CAAC,CAAC;AAEH,oFAAoF;AACpF,MAAM,CAAC,MAAM,KAAK,GAAyB,GAAG,CAAC;;;;;;CAM9C,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;;;;;;;;CASrD,CAAC,CAAC;AAEH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,qBAAqB,GAAyB,GAAG,CAAC;;;;;;;;CAQ9D,CAAC,CAAC;AAEH,4DAA4D;AAC5D,MAAM,CAAC,MAAM,iBAAiB,GAAyB,GAAG,CAAC;;;CAG1D,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBrD,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,GAAG,CAAC;;;;;;;;;;;;;;;;;;;CAmBrD,CAAC,CAAC;AAEH,kEAAkE;AAClE,MAAM,CAAC,MAAM,sBAAsB,GAAyB,GAAG,CAAC;;CAE/D,CAAC,CAAC;AAEH,qGAAqG;AACrG,MAAM,CAAC,MAAM,oBAAoB,GAAyB,GAAG,CAAC,iDAAiD,CAAC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type Severity = "error" | "warning";
+/** The setting of a rule in `ste.config.json`. */
+export type RuleSetting = Severity | "off";
+export declare const RULE_IDS: readonly ["sentence-length", "paragraph-length", "modal-verb", "semicolon", "latin-abbreviation", "about-quantity", "word-list", "gendered-pronoun", "first-person", "passive-instruction", "noun-cluster", "missing-subject", "ing-verb", "unknown-word"];
+export type RuleId = (typeof RULE_IDS)[number];
+/** One problem that the linter found. Lines and columns start at 1. */
+export type Finding = {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    readonly endLine: number;
+    readonly endColumn: number;
+    readonly ruleId: RuleId;
+    readonly severity: Severity;
+    readonly message: string;
+};
+export declare function isRuleId(value: string): value is RuleId;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAE3C,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE3C,eAAO,MAAM,QAAQ,4PAeX,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,uEAAuE;AACvE,MAAM,MAAM,OAAO,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAG,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAG,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAG,QAAQ,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAC;CAC7B,CAAC;AAEF,wBAAgB,QAAQ,CAAC,KAAK,EAAG,MAAM,GAAI,KAAK,IAAI,MAAM,CAEzD"}

package/dist/types.js

@@ -0,0 +1,20 @@
+export const RULE_IDS = [
+    "sentence-length",
+    "paragraph-length",
+    "modal-verb",
+    "semicolon",
+    "latin-abbreviation",
+    "about-quantity",
+    "word-list",
+    "gendered-pronoun",
+    "first-person",
+    "passive-instruction",
+    "noun-cluster",
+    "missing-subject",
+    "ing-verb",
+    "unknown-word",
+];
+export function isRuleId(value) {
+    return RULE_IDS.includes(value);
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,MAAM,QAAQ,GAAG;IACpB,iBAAiB;IACjB,kBAAkB;IAClB,YAAY;IACZ,WAAW;IACX,oBAAoB;IACpB,gBAAgB;IAChB,WAAW;IACX,kBAAkB;IAClB,cAAc;IACd,qBAAqB;IACrB,cAAc;IACd,iBAAiB;IACjB,UAAU;IACV,cAAc;CACR,CAAC;AAgBX,MAAM,UAAU,QAAQ,CAAC,KAAc;IACnC,OAAQ,QAA8B,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC"}

package/dist/units.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Prose units: the blocks of text that the rules examine, with their tokens
+ * and sentences.
+ */
+import type { Lexicon } from "./lexicon.js";
+import type { ListContext, ProseBlock } from "./source/blocks.js";
+import { type Token } from "./text/tokens.js";
+export type TsdocSection = "summary" | "remarks" | "tag";
+/** Where a block comes from. */
+export type BlockOrigin = {
+    readonly source: "markdown" | "mdx" | "tsdoc" | "jsx";
+    /** For a doc comment: the summary, the `@remarks` section, or the text of another block tag. */
+    readonly tsdocSection: TsdocSection | null;
+    /** For a doc comment: the block tag, for example `@param`, or null for the summary. */
+    readonly tsdocTag: string | null;
+};
+export type ExtractedBlock = {
+    readonly block: ProseBlock;
+    readonly origin: BlockOrigin;
+};
+export type Sentence = {
+    /** All tokens of the sentence, with the punctuation. */
+    readonly tokens: readonly Token[];
+    /** The STE word count. */
+    readonly words: number;
+    /** The tokens in each top-level parenthesis. Each one counts as a separate sentence. */
+    readonly parentheticals: readonly (readonly Token[])[];
+    /** True when the sentence is an instruction (imperative). */
+    readonly instruction: boolean;
+    readonly start: number;
+    readonly end: number;
+};
+export type UnitKind = ProseBlock["kind"];
+export type ProseUnit = {
+    readonly kind: UnitKind;
+    readonly origin: BlockOrigin;
+    readonly list: ListContext | null;
+    readonly tokens: readonly Token[];
+    readonly sentences: readonly Sentence[];
+    readonly start: number;
+    readonly end: number;
+};
+/** This function makes a prose unit from a block. The result is null when the block has no words. */
+export declare function buildUnit(extracted: ExtractedBlock, lexicon: Lexicon): ProseUnit | null;
+/** This function makes a prose unit from the tokens of a block. */
+export declare function unitFromTokens(tokens: readonly Token[], block: Pick<ProseBlock, "kind" | "list">, origin: BlockOrigin, lexicon: Lexicon): ProseUnit | null;
+//# sourceMappingURL=units.d.ts.map

package/dist/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../src/units.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIlE,OAAO,EAAuB,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEnE,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;AAEzD,gCAAgC;AAChC,MAAM,MAAM,WAAW,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAG,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,CAAC;IACvD,gGAAgG;IAChG,QAAQ,CAAC,YAAY,EAAG,YAAY,GAAG,IAAI,CAAC;IAC5C,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAG,MAAM,GAAG,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAG,UAAU,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAG,WAAW,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACnB,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAG,SAAS,KAAK,EAAE,CAAC;IACnC,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAC;IACxB,wFAAwF;IACxF,QAAQ,CAAC,cAAc,EAAG,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,CAAC;IACxD,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAG,OAAO,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAG,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;AAE1C,MAAM,MAAM,SAAS,GAAG;IACpB,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAG,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAG,WAAW,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAG,SAAS,KAAK,EAAE,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAG,SAAS,QAAQ,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAG,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAG,MAAM,CAAC;CACzB,CAAC;AAEF,qGAAqG;AACrG,wBAAgB,SAAS,CAAC,SAAS,EAAG,cAAc,EAAE,OAAO,EAAG,OAAO,GAAI,SAAS,GAAG,IAAI,CAI1F;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,MAAM,EAAG,SAAS,KAAK,EAAE,EAAE,KAAK,EAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,MAAM,EAAG,WAAW,EAAE,OAAO,EAAG,OAAO,GAAI,SAAS,GAAG,IAAI,CAwB/J"}

package/dist/units.js

@@ -0,0 +1,42 @@
+/**
+ * Prose units: the blocks of text that the rules examine, with their tokens
+ * and sentences.
+ */
+import { normalizeInline } from "./source/inline.js";
+import { isInstruction } from "./text/grammar.js";
+import { countWords, splitSentences } from "./text/sentences.js";
+import { isCounted, tokenize } from "./text/tokens.js";
+/** This function makes a prose unit from a block. The result is null when the block has no words. */
+export function buildUnit(extracted, lexicon) {
+    const { block, origin } = extracted;
+    const inline = normalizeInline(block.lines, { mdx: origin.source === "mdx" || origin.source === "jsx", tsdoc: origin.source === "tsdoc" });
+    return unitFromTokens(tokenize(inline), block, origin, lexicon);
+}
+/** This function makes a prose unit from the tokens of a block. */
+export function unitFromTokens(tokens, block, origin, lexicon) {
+    if (!tokens.some(isCounted))
+        return null;
+    const ranges = block.kind === "paragraph" ? splitSentences(tokens) : [{ from: 0, to: tokens.length }];
+    const sentences = ranges.map((range) => {
+        const sentenceTokens = tokens.slice(range.from, range.to);
+        const count = countWords(sentenceTokens, { properNouns: lexicon.properNounPhrases });
+        return {
+            tokens: sentenceTokens,
+            words: count.words,
+            parentheticals: count.parentheticals,
+            instruction: block.kind === "paragraph" && isInstruction(sentenceTokens, { verbs: lexicon.verbs }),
+            start: sentenceTokens[0].start,
+            end: sentenceTokens[sentenceTokens.length - 1].end,
+        };
+    });
+    return {
+        kind: block.kind,
+        origin,
+        list: block.list,
+        tokens,
+        sentences,
+        start: tokens[0].start,
+        end: tokens[tokens.length - 1].end,
+    };
+}
+//# sourceMappingURL=units.js.map

package/dist/units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.js","sourceRoot":"","sources":["../src/units.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAc,MAAM,kBAAkB,CAAC;AA2CnE,qGAAqG;AACrG,MAAM,UAAU,SAAS,CAAC,SAA0B,EAAE,OAAiB;IACnE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACpC,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,GAAG,EAAG,MAAM,CAAC,MAAM,KAAK,KAAK,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK,EAAE,KAAK,EAAG,MAAM,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC,CAAC;IAC7I,OAAO,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACpE,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,cAAc,CAAC,MAAyB,EAAE,KAAyC,EAAE,MAAoB,EAAE,OAAiB;IACxI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IACzC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAG,CAAC,EAAE,EAAE,EAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IACxG,MAAM,SAAS,GAAgB,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAChD,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,UAAU,CAAC,cAAc,EAAE,EAAE,WAAW,EAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC;QACtF,OAAO;YACH,MAAM,EAAG,cAAc;YACvB,KAAK,EAAG,KAAK,CAAC,KAAK;YACnB,cAAc,EAAG,KAAK,CAAC,cAAc;YACrC,WAAW,EAAG,KAAK,CAAC,IAAI,KAAK,WAAW,IAAI,aAAa,CAAC,cAAc,EAAE,EAAE,KAAK,EAAG,OAAO,CAAC,KAAK,EAAE,CAAC;YACpG,KAAK,EAAG,cAAc,CAAC,CAAC,CAAE,CAAC,KAAK;YAChC,GAAG,EAAG,cAAc,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,GAAG;SACvD,CAAC;IACN,CAAC,CAAC,CAAC;IACH,OAAO;QACH,IAAI,EAAG,KAAK,CAAC,IAAI;QACjB,MAAM;QACN,IAAI,EAAG,KAAK,CAAC,IAAI;QACjB,MAAM;QACN,SAAS;QACT,KAAK,EAAG,MAAM,CAAC,CAAC,CAAE,CAAC,KAAK;QACxB,GAAG,EAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,GAAG;KACvC,CAAC;AACN,CAAC"}

package/dist/word-list.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The project word list: plain-language substitutions for the documentation
+ * of this repository. This list is the style guide of the project, written
+ * for it. It is not a copy of the ASD-STE100 dictionary. The local
+ * dictionary file (refer to `dictionary.ts`) does that job, and it is not
+ * part of the repository at any time.
+ *
+ * Each entry has the words or phrases to find, the words to write instead,
+ * and a severity. `ste.config.json` can add entries, change them, or set an
+ * entry to "off".
+ */
+import type { Severity } from "./types.js";
+export type WordListEntry = {
+    /** A short name of the entry. A configuration entry with the same ID changes this entry. */
+    readonly id: string;
+    /** The words and phrases to find. The match ignores case. */
+    readonly match: readonly string[];
+    /** The words to write instead, as the message shows them. Null when the fix is to remove the word. */
+    readonly suggest: string | null;
+    /** More help for the message, or null. */
+    readonly note: string | null;
+    readonly severity: Severity;
+    /**
+     * True when the word can be a noun too. Then the rule reports the word
+     * only when the words near it show a verb ("Run the tests", but not "a
+     * test run").
+     */
+    readonly verbOnly: boolean;
+    /** A special context: "reference" finds "see" only where it tells the reader to look at other text. */
+    readonly context: "reference" | null;
+};
+/** The default word list. */
+export declare const DEFAULT_WORD_LIST: readonly WordListEntry[];
+//# sourceMappingURL=word-list.d.ts.map

package/dist/word-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-list.d.ts","sourceRoot":"","sources":["../src/word-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,aAAa,GAAG;IACxB,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,EAAG,MAAM,CAAC;IACrB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAG,SAAS,MAAM,EAAE,CAAC;IACnC,sGAAsG;IACtG,QAAQ,CAAC,OAAO,EAAG,MAAM,GAAG,IAAI,CAAC;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAG,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAG,QAAQ,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAG,OAAO,CAAC;IAC5B,uGAAuG;IACvG,QAAQ,CAAC,OAAO,EAAG,WAAW,GAAG,IAAI,CAAC;CACzC,CAAC;AAwBF,6BAA6B;AAC7B,eAAO,MAAM,iBAAiB,EAAG,SAAS,aAAa,EAsEtD,CAAC"}