slopless 0.2.22 → 0.2.23

package/README.md

@@ -160,10 +160,6 @@ npm audit signatures slopless
 
 This confirms the tarball you installed was built in the published source repository's Actions environment, from the commit the GitHub Release points at.
 
-## Star history
-
-[![Star History Chart](https://api.star-history.com/svg?repos=seochecks-ai/slopless&type=Date)](https://star-history.com/#seochecks-ai/slopless&Date)
-
 ## Credits
 
 [Graham Rowe](https://github.com/grahamrowe82/antislop), thanks for giving me new ideas for classes of slop to detect. Your lib is now fully incorporated with your permission.

package/dist/rules/syntactic-patterns/repetition/fragment-stacking.js

@@ -1,285 +1,7 @@
-import { hasConcreteInventorySubjects } from "../../../shared/matchers/concrete-evidence.js";
-import { splitSentences } from "../../../shared/text/sentences.js";
-import { splitWhitespace } from "../../../shared/text/whitespace.js";
 import { oneToOneRule } from "../../private/textlint-rule-builders.js";
-const MAX_FRAGMENT_WORDS = 6;
-const MAX_PAYOFF_WORDS = 28;
-const SUBJECT_WORDS = new Set([
-    "i",
-    "you",
-    "we",
-    "they",
-    "he",
-    "she",
-    "it",
-    "this",
-    "that",
-    "these",
-    "those"
-]);
-const OBJECT_WORDS = new Set([
-    "me",
-    "him",
-    "her",
-    "us",
-    "them",
-    "it",
-    "the",
-    "a",
-    "an",
-    "my",
-    "your",
-    "our",
-    "their"
-]);
-const FINITE_VERBS = new Set([
-    "is",
-    "are",
-    "was",
-    "were",
-    "am",
-    "be",
-    "been",
-    "being",
-    "have",
-    "has",
-    "had",
-    "do",
-    "does",
-    "did",
-    "can",
-    "could",
-    "will",
-    "would",
-    "should",
-    "may",
-    "might",
-    "must",
-    "shall"
-]);
-const FRAGMENT_LEADS = new Set([
-    "too",
-    "most",
-    "more",
-    "less",
-    "deeply",
-    "completely",
-    "possibly",
-    "probably",
-    "maybe",
-    "weird",
-    "strange",
-    "odd",
-    "pure",
-    "total",
-    "incredibly"
-]);
-const PAYOFF_STARTS = ["more like ", "most ", "then ", "instead "];
-const IMPERATIVE_STARTS = new Set([
-    "feed",
-    "leave",
-    "notice",
-    "stop",
-    "start",
-    "take",
-    "keep",
-    "get",
-    "look",
-    "think",
-    "try",
-    "make",
-    "let",
-    "give",
-    "accept",
-    "hold",
-    "reduce"
-]);
-const SIMPLE_PAST_VERBS = new Set([
-    "ran",
-    "went",
-    "came",
-    "felt",
-    "heard",
-    "found",
-    "made",
-    "took",
-    "kept",
-    "left",
-    "thought",
-    "knew",
-    "got",
-    "put",
-    "said",
-    "told",
-    "held",
-    "stood",
-    "sat",
-    "became",
-    "wrote",
-    "spoke",
-    "won",
-    "lost",
-    "paid",
-    "met",
-    "read",
-    "saw",
-    "grew",
-    "fell",
-    "broke"
-]);
-function isAlphanumeric(character) {
-    const lower = character.toLocaleLowerCase("en");
-    const upper = character.toLocaleUpperCase("en");
-    return (character >= "0" && character <= "9") || lower !== upper;
-}
-function cleanWord(word) {
-    const normalized = word.toLocaleLowerCase("en").replaceAll("\u2019", "'");
-    let start = 0;
-    let end = normalized.length;
-    while (start < end &&
-        normalized[start] !== "'" &&
-        !isAlphanumeric(normalized[start] ?? "")) {
-        start += 1;
-    }
-    while (end > start &&
-        normalized[end - 1] !== "'" &&
-        !isAlphanumeric(normalized[end - 1] ?? "")) {
-        end -= 1;
-    }
-    return normalized.slice(start, end);
-}
-function sentenceWords(sentence) {
-    return splitWhitespace(sentence).map(cleanWord);
-}
-function isFunctionWord(word) {
-    return (word === "the" ||
-        word === "a" ||
-        word === "an" ||
-        word === "and" ||
-        word === "or" ||
-        word === "but" ||
-        word === "to" ||
-        word === "of" ||
-        word === "in" ||
-        word === "on" ||
-        word === "at" ||
-        word === "for");
-}
-function looksLikeModifierPhrase(first, second) {
-    return (first.endsWith("ly") ||
-        second.endsWith("ive") ||
-        second.endsWith("ous") ||
-        second.endsWith("al") ||
-        second.endsWith("ful") ||
-        second.endsWith("less"));
-}
-function looksLikeSubjectDrop(first, second) {
-    return (((first.endsWith("ed") && !first.endsWith("eed")) ||
-        first.endsWith("ing")) &&
-        !isFunctionWord(second));
-}
-function looksLikeSimpleClause(first, second) {
-    return (!isFunctionWord(first) &&
-        (second.endsWith("ed") || SIMPLE_PAST_VERBS.has(second)));
-}
-function looksLikeBriefImperative(first, second) {
-    return (IMPERATIVE_STARTS.has(first) &&
-        (OBJECT_WORDS.has(second) || second.endsWith("er") || second.endsWith("ly")));
-}
-function classifyFragment(sentence) {
-    const words = sentenceWords(sentence.text);
-    if (words.length < 2 || words.length > MAX_FRAGMENT_WORDS) {
-        return undefined;
-    }
-    if (words.some((word) => word === "")) {
-        return undefined;
-    }
-    if (words.some((word) => SUBJECT_WORDS.has(word))) {
-        return undefined;
-    }
-    if (words.some((word) => FINITE_VERBS.has(word))) {
-        return undefined;
-    }
-    const first = words[0];
-    const second = words[1];
-    if (first === undefined || second === undefined) {
-        return undefined;
-    }
-    if (FRAGMENT_LEADS.has(first) || looksLikeModifierPhrase(first, second)) {
-        return "modifier-fragment";
-    }
-    if (looksLikeSimpleClause(first, second) ||
-        looksLikeBriefImperative(first, second)) {
-        return undefined;
-    }
-    if (looksLikeSubjectDrop(first, second)) {
-        return "subject-drop";
-    }
-    return "noun-fragment";
-}
-function looksLikePayoffSentence(sentence) {
-    const words = sentenceWords(sentence.text);
-    if (words.length <= 2 || words.length > MAX_PAYOFF_WORDS) {
-        return false;
-    }
-    const lowered = sentence.text.toLocaleLowerCase("en");
-    if (!PAYOFF_STARTS.some((start) => lowered.startsWith(start))) {
-        return false;
-    }
-    return !words.some((word) => SUBJECT_WORDS.has(word));
-}
-function findFragmentStacks(text) {
-    const sentences = splitSentences(text);
-    const classifications = sentences.map(classifyFragment);
-    const matches = [];
-    let sentenceIndex = 0;
-    while (sentenceIndex < sentences.length) {
-        const firstType = classifications[sentenceIndex];
-        const firstSentence = sentences[sentenceIndex];
-        if (firstType === undefined || firstSentence === undefined) {
-            sentenceIndex += 1;
-            continue;
-        }
-        const runSentences = [firstSentence];
-        const fragmentTypes = [firstType];
-        let cursor = sentenceIndex + 1;
-        while (cursor < sentences.length) {
-            const sentence = sentences[cursor];
-            const nextType = classifications[cursor];
-            if (sentence === undefined) {
-                break;
-            }
-            if (nextType !== undefined) {
-                runSentences.push(sentence);
-                fragmentTypes.push(nextType);
-                cursor += 1;
-                continue;
-            }
-            if (looksLikePayoffSentence(sentence)) {
-                runSentences.push(sentence);
-                cursor += 1;
-            }
-            break;
-        }
-        if (fragmentTypes.length >= 2 &&
-            runSentences.length >= 3 &&
-            !hasConcreteInventorySubjects(runSentences.map((sentence) => sentence.text))) {
-            const last = runSentences[runSentences.length - 1];
-            if (last !== undefined) {
-                matches.push({
-                    end: last.end,
-                    fragmentTypes,
-                    sentences: runSentences.map((sentence) => sentence.text),
-                    start: firstSentence.start
-                });
-            }
-        }
-        sentenceIndex = Math.max(cursor, sentenceIndex + 1);
-    }
-    return matches;
-}
+import { findFragmentMatches } from "./private/fragment-stack-detector.js";
 const rule = oneToOneRule({
-    detect: (unit) => findFragmentStacks(unit.text).map((match) => ({
+    detect: (unit) => findFragmentMatches(unit.text).map((match) => ({
         evidence: match.sentences.join(" "),
         label: match.fragmentTypes.join(","),
         range: { start: match.start, end: match.end }

package/dist/rules/syntactic-patterns/repetition/private/fragment-stack-detector.js

@@ -0,0 +1,316 @@
+import { hasConcreteInventorySubjects } from "../../../../shared/matchers/concrete-evidence.js";
+import { splitSentences } from "../../../../shared/text/sentences.js";
+import { splitWhitespace } from "../../../../shared/text/whitespace.js";
+const MAX_FRAGMENT_WORDS = 6;
+const MAX_NO_FRAGMENT_WORDS = 5;
+const MAX_PAYOFF_WORDS = 28;
+const SUBJECT_WORDS = new Set([
+    "i",
+    "you",
+    "we",
+    "they",
+    "he",
+    "she",
+    "it",
+    "this",
+    "that",
+    "these",
+    "those"
+]);
+const OBJECT_WORDS = new Set([
+    "me",
+    "him",
+    "her",
+    "us",
+    "them",
+    "it",
+    "the",
+    "a",
+    "an",
+    "my",
+    "your",
+    "our",
+    "their"
+]);
+const FINITE_VERBS = new Set([
+    "is",
+    "are",
+    "was",
+    "were",
+    "am",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "can",
+    "could",
+    "will",
+    "would",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall"
+]);
+const FRAGMENT_LEADS = new Set([
+    "too",
+    "most",
+    "more",
+    "less",
+    "deeply",
+    "completely",
+    "possibly",
+    "probably",
+    "maybe",
+    "weird",
+    "strange",
+    "odd",
+    "pure",
+    "total",
+    "incredibly"
+]);
+const PAYOFF_STARTS = ["more like ", "most ", "then ", "instead "];
+const IMPERATIVE_STARTS = new Set([
+    "feed",
+    "leave",
+    "notice",
+    "stop",
+    "start",
+    "take",
+    "keep",
+    "get",
+    "look",
+    "think",
+    "try",
+    "make",
+    "let",
+    "give",
+    "accept",
+    "hold",
+    "reduce"
+]);
+const SIMPLE_PAST_VERBS = new Set([
+    "ran",
+    "went",
+    "came",
+    "felt",
+    "heard",
+    "found",
+    "made",
+    "took",
+    "kept",
+    "left",
+    "thought",
+    "knew",
+    "got",
+    "put",
+    "said",
+    "told",
+    "held",
+    "stood",
+    "sat",
+    "became",
+    "wrote",
+    "spoke",
+    "won",
+    "lost",
+    "paid",
+    "met",
+    "read",
+    "saw",
+    "grew",
+    "fell",
+    "broke"
+]);
+function isAlphanumeric(character) {
+    const lower = character.toLocaleLowerCase("en");
+    const upper = character.toLocaleUpperCase("en");
+    return (character >= "0" && character <= "9") || lower !== upper;
+}
+function cleanWord(word) {
+    const normalized = word.toLocaleLowerCase("en").replaceAll("\u2019", "'");
+    let start = 0;
+    let end = normalized.length;
+    while (start < end &&
+        normalized[start] !== "'" &&
+        !isAlphanumeric(normalized[start] ?? "")) {
+        start += 1;
+    }
+    while (end > start &&
+        normalized[end - 1] !== "'" &&
+        !isAlphanumeric(normalized[end - 1] ?? "")) {
+        end -= 1;
+    }
+    return normalized.slice(start, end);
+}
+function sentenceWords(sentence) {
+    return splitWhitespace(sentence).map(cleanWord);
+}
+function isFunctionWord(word) {
+    return (word === "the" ||
+        word === "a" ||
+        word === "an" ||
+        word === "and" ||
+        word === "or" ||
+        word === "but" ||
+        word === "to" ||
+        word === "of" ||
+        word === "in" ||
+        word === "on" ||
+        word === "at" ||
+        word === "for");
+}
+function looksLikeModifierPhrase(first, second) {
+    return (first.endsWith("ly") ||
+        second.endsWith("ive") ||
+        second.endsWith("ous") ||
+        second.endsWith("al") ||
+        second.endsWith("ful") ||
+        second.endsWith("less"));
+}
+function looksLikeSubjectDrop(first, second) {
+    return (((first.endsWith("ed") && !first.endsWith("eed")) ||
+        first.endsWith("ing")) &&
+        !isFunctionWord(second));
+}
+function looksLikeSimpleClause(first, second) {
+    return (!isFunctionWord(first) &&
+        (second.endsWith("ed") || SIMPLE_PAST_VERBS.has(second)));
+}
+function looksLikeBriefImperative(first, second) {
+    return (IMPERATIVE_STARTS.has(first) &&
+        (OBJECT_WORDS.has(second) || second.endsWith("er") || second.endsWith("ly")));
+}
+function classifyFragment(sentence) {
+    const words = sentenceWords(sentence.text);
+    if (words.length < 2 || words.length > MAX_FRAGMENT_WORDS) {
+        return undefined;
+    }
+    if (words.some((word) => word === "")) {
+        return undefined;
+    }
+    if (words.some((word) => SUBJECT_WORDS.has(word))) {
+        return undefined;
+    }
+    if (words.some((word) => FINITE_VERBS.has(word))) {
+        return undefined;
+    }
+    const first = words[0];
+    const second = words[1];
+    if (first === undefined || second === undefined) {
+        return undefined;
+    }
+    if (FRAGMENT_LEADS.has(first) || looksLikeModifierPhrase(first, second)) {
+        return "modifier-fragment";
+    }
+    if (looksLikeSimpleClause(first, second) ||
+        looksLikeBriefImperative(first, second)) {
+        return undefined;
+    }
+    if (looksLikeSubjectDrop(first, second)) {
+        return "subject-drop";
+    }
+    return "noun-fragment";
+}
+function looksLikePayoffSentence(sentence) {
+    const words = sentenceWords(sentence.text);
+    if (words.length <= 2 || words.length > MAX_PAYOFF_WORDS) {
+        return false;
+    }
+    const lowered = sentence.text.toLocaleLowerCase("en");
+    if (!PAYOFF_STARTS.some((start) => lowered.startsWith(start))) {
+        return false;
+    }
+    return !words.some((word) => SUBJECT_WORDS.has(word));
+}
+function isNoFragment(sentence) {
+    const words = sentenceWords(sentence.text);
+    return (words.length >= 2 &&
+        words.length <= MAX_NO_FRAGMENT_WORDS &&
+        words[0] === "no" &&
+        !words.some((word) => FINITE_VERBS.has(word)) &&
+        classifyFragment(sentence) === "noun-fragment");
+}
+function findNoFragmentPairs(text) {
+    const sentences = splitSentences(text);
+    const matches = [];
+    for (let index = 0; index < sentences.length - 1; index += 1) {
+        const first = sentences[index];
+        const second = sentences[index + 1];
+        if (first === undefined || second === undefined) {
+            continue;
+        }
+        const pair = [first.text, second.text];
+        if (!isNoFragment(first) ||
+            !isNoFragment(second) ||
+            hasConcreteInventorySubjects(pair)) {
+            continue;
+        }
+        matches.push({
+            end: second.end,
+            fragmentTypes: ["no-fragment", "no-fragment"],
+            sentences: pair,
+            start: first.start
+        });
+    }
+    return matches;
+}
+function findFragmentStacks(text) {
+    const sentences = splitSentences(text);
+    const classifications = sentences.map(classifyFragment);
+    const matches = [];
+    let sentenceIndex = 0;
+    while (sentenceIndex < sentences.length) {
+        const firstType = classifications[sentenceIndex];
+        const firstSentence = sentences[sentenceIndex];
+        if (firstType === undefined || firstSentence === undefined) {
+            sentenceIndex += 1;
+            continue;
+        }
+        const runSentences = [firstSentence];
+        const fragmentTypes = [firstType];
+        let cursor = sentenceIndex + 1;
+        while (cursor < sentences.length) {
+            const sentence = sentences[cursor];
+            const nextType = classifications[cursor];
+            if (sentence === undefined) {
+                break;
+            }
+            if (nextType !== undefined) {
+                runSentences.push(sentence);
+                fragmentTypes.push(nextType);
+                cursor += 1;
+                continue;
+            }
+            if (looksLikePayoffSentence(sentence)) {
+                runSentences.push(sentence);
+                cursor += 1;
+            }
+            break;
+        }
+        if (fragmentTypes.length >= 2 &&
+            runSentences.length >= 3 &&
+            !hasConcreteInventorySubjects(runSentences.map((sentence) => sentence.text))) {
+            const last = runSentences[runSentences.length - 1];
+            if (last !== undefined) {
+                matches.push({
+                    end: last.end,
+                    fragmentTypes,
+                    sentences: runSentences.map((sentence) => sentence.text),
+                    start: firstSentence.start
+                });
+            }
+        }
+        sentenceIndex = Math.max(cursor, sentenceIndex + 1);
+    }
+    return matches;
+}
+export function findFragmentMatches(text) {
+    return [...findNoFragmentPairs(text), ...findFragmentStacks(text)];
+}
+//# sourceMappingURL=fragment-stack-detector.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.22",
+  "version": "0.2.23",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",