slopless 0.2.26 → 0.2.28

package/dist/adapters/textlint/units.js

@@ -1,6 +1,6 @@
 import { normalizeForMatch } from "../../shared/text/normalize.js";
 import { allParagraphSentences, allParagraphs, sectionFirstSentences, sectionLastSentences } from "../../shared/text/sections.js";
-import { documentText } from "../../shared/text/document.js";
+import { documentSourceText, documentText } from "../../shared/text/document.js";
 import { sourceText } from "../../shared/text/traverse.js";
 function isParentNode(node) {
     return "children" in node;
@@ -44,14 +44,18 @@ function sentenceUnit(id, item) {
     };
 }
 export function documentUnit(document) {
-    const text = documentText(document);
+    const source = documentSourceText(document);
+    const { text } = source;
     return {
         id: "document:0",
         kind: "document",
         node: document,
         normalizedText: normalizeForMatch(text),
         range: { end: text.length, start: 0 },
-        sourceRangeFor: (range) => range,
+        sourceRangeFor: (range) => ({
+            end: source.originalEndFor(range.end),
+            start: source.originalStartFor(range.start)
+        }),
         text
     };
 }

package/dist/presets/everything.js

@@ -42,6 +42,7 @@ export const everything = {
         "perception-verb-density": true,
         "prohibited-phrases": true,
         "prohibited-words": true,
+        "quietly-overuse": true,
         "recommended-terms": true,
         redundancy: true,
         "repeated-predicate-end": true,

package/dist/registries/words.js

@@ -3,6 +3,7 @@ import hedgeStacking from "../rules/words/hedge-stacking.js";
 import llmVocabularyDensity from "../rules/words/llm-vocabulary-density.js";
 import llmVocabulary from "../rules/words/llm-vocabulary.js";
 import prohibitedWords from "../rules/words/prohibited-words.js";
+import quietlyOveruse from "../rules/words/quietly-overuse.js";
 import simplicity from "../rules/words/simplicity.js";
 export const wordRules = {
     "actually-overuse": actuallyOveruse,
@@ -10,6 +11,7 @@ export const wordRules = {
     "llm-vocabulary-density": llmVocabularyDensity,
     "llm-vocabulary": llmVocabulary,
     "prohibited-words": prohibitedWords,
+    "quietly-overuse": quietlyOveruse,
     simplicity
 };
 //# sourceMappingURL=words.js.map

package/dist/rules/semantic-thinness/patterns/something-shifted.json

@@ -2,14 +2,36 @@
     "id": "something-shifted",
     "class": "vague-change",
     "purpose": "Catch vague change declarations that say something shifted, changed, moved, or crossed a line without naming the concrete change.",
-    "matchMode": "contains",
+    "matchMode": "full",
     "maxTokens": 80,
     "templates": [
-        "{genericSubject} {changeVerb}.",
-        "{genericSubject} had {changeVerb}.",
-        "{genericSubject} in {abstractContainer} had {changeVerb}.",
-        "{concreteSubject} did not {changeVerb}, but {genericSubject} in it did.",
-        "{genericSubject} {changeVerb} when {genericSubject} {abstractAction}."
+        {
+            "text": "{genericSubject} {changeVerb}.",
+            "matchMode": "contains"
+        },
+        {
+            "text": "{genericSubject} had {changeVerb}.",
+            "matchMode": "contains"
+        },
+        {
+            "text": "{genericSubject} in {abstractContainer} had {changeVerb}.",
+            "matchMode": "contains"
+        },
+        {
+            "text": "{concreteSubject} did not {changeVerb}, but {genericSubject} in it did.",
+            "matchMode": "contains"
+        },
+        {
+            "text": "{genericSubject} {changeVerb} when {genericSubject} {abstractAction}.",
+            "matchMode": "contains"
+        },
+        "{diffuseSubject} {weakMannerAdverb} {finiteChange}.",
+        "{diffuseSubject} {progressiveAuxiliary} {weakMannerAdverb} {progressiveChange}.",
+        "{diffuseSubject} {perfectAuxiliary} {weakMannerAdverb} {pastChange}.",
+        "{diffuseSubject} {finiteChange} {weakMannerAdverb}.",
+        "{deicticSubject} {weakMannerAdverb} {emptyChangeObject}.",
+        "{shiftDeterminer} {shiftModifier} shift {emptyShiftPredicate}.",
+        "{deicticSubject} {signalVerb} {shiftDeterminer} {shiftModifier} shift."
     ],
     "slots": {
         "genericSubject": [
@@ -45,7 +67,103 @@
             "chose differently",
             "named the truth",
             "let go"
-        ]
+        ],
+        "diffuseSubject": [
+            "the market",
+            "the industry",
+            "search",
+            "the web",
+            "the landscape",
+            "the platform",
+            "the system",
+            "the process",
+            "the conversation",
+            "the work",
+            "the strategy",
+            "the model",
+            "the product",
+            "the category",
+            "the space"
+        ],
+        "progressiveAuxiliary": ["is", "was", "has been", "had been"],
+        "perfectAuxiliary": ["has", "had"],
+        "weakMannerAdverb": [
+            "quietly",
+            "silently",
+            "subtly",
+            "gradually",
+            "steadily",
+            "almost invisibly",
+            "under the surface"
+        ],
+        "finiteChange": [
+            "changes",
+            "shifts",
+            "evolves",
+            "transforms",
+            "reshapes",
+            "redefines",
+            "moves",
+            "changed",
+            "shifted",
+            "evolved",
+            "transformed",
+            "reshaped",
+            "redefined",
+            "moved"
+        ],
+        "pastChange": [
+            "changed",
+            "shifted",
+            "evolved",
+            "transformed",
+            "reshaped",
+            "redefined",
+            "moved"
+        ],
+        "progressiveChange": [
+            "changing",
+            "shifting",
+            "evolving",
+            "transforming",
+            "reshaping",
+            "redefining",
+            "moving"
+        ],
+        "deicticSubject": ["this", "that", "it"],
+        "emptyChangeObject": [
+            "changes everything",
+            "changes the game",
+            "changes the equation",
+            "reshapes everything",
+            "redefines everything"
+        ],
+        "shiftDeterminer": ["a", "the", "this", "that"],
+        "shiftModifier": [
+            "quiet",
+            "subtle",
+            "broader",
+            "meaningful",
+            "important",
+            "major",
+            "fundamental",
+            "seismic",
+            "structural",
+            "profound",
+            "significant",
+            "notable"
+        ],
+        "emptyShiftPredicate": [
+            "is underway",
+            "is happening",
+            "has begun",
+            "is already here",
+            "is easy to miss",
+            "is hard to ignore",
+            "matters",
+            "changes everything"
+        ],
+        "signalVerb": ["marks", "signals", "represents", "reflects"]
     },
     "rejectIf": [
         "sentence names what changed",

package/dist/rules/syntactic-patterns/lead-ins/generic-signposting.js

@@ -159,7 +159,7 @@ function matchWhatFrame(words) {
 function matchAbstractFrame(text) {
     const words = tokens(text);
     return (matchRelativeDiscourseFrame(text, words) ??
-        matchExpandedDiscourseFrame(words) ??
+        matchExpandedDiscourseFrame(text, words) ??
         matchModifiedAbstractFrame(words) ??
         matchDiscourseEvaluationFrame(words) ??
         matchPointIsToFrame(words) ??
@@ -221,6 +221,7 @@ function matchSignposting(sentence) {
     const generatedFormula = matchGeneratedFormula(stripped);
     if (abstract !== undefined &&
         (abstract === "what-matters-is" ||
+            abstract.startsWith("deictic-evaluative-") ||
             abstract.startsWith("relative-") ||
             !concreteImplementation)) {
         return { kind: "abstract-evaluation-frame", signal: abstract };

package/dist/rules/syntactic-patterns/lead-ins/private/discourse-evaluation.js

@@ -5,6 +5,53 @@ const DISCOURSE_WORK_TAILS = [
     ["load", "bearing"]
 ];
 const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const DEICTIC_OPENERS = new Set(["here", "this", "that"]);
+const DEICTIC_CONTRACTIONS = new Map([
+    ["here's", "here"],
+    ["this's", "this"],
+    ["that's", "that"]
+]);
+const DEICTIC_EVALUATIVE_ADJECTIVES = new Set([
+    "best",
+    "better",
+    "biggest",
+    "central",
+    "core",
+    "crucial",
+    "funny",
+    "good",
+    "great",
+    "hard",
+    "important",
+    "interesting",
+    "key",
+    "main",
+    "neat",
+    "nice",
+    "odd",
+    "obvious",
+    "remarkable",
+    "strange",
+    "surprising",
+    "tricky",
+    "useful",
+    "weird",
+    "wild"
+]);
+const DEICTIC_DISCOURSE_NOUNS = new Set([
+    "angle",
+    "aspect",
+    "bit",
+    "catch",
+    "detail",
+    "element",
+    "idea",
+    "part",
+    "piece",
+    "point",
+    "thing",
+    "twist"
+]);
 const FRAME_ADJECTIVES = new Set([
     "basic",
     "best",
@@ -202,13 +249,45 @@ function matchEvaluativeFrame(words) {
         ? `the-${adjective}-${noun}-${verb}`
         : undefined;
 }
+function matchDeicticEvaluativeFrame(text, words) {
+    const contractedOpener = DEICTIC_CONTRACTIONS.get(words[0] ?? "");
+    const opener = contractedOpener ?? words[0];
+    const determinerIndex = contractedOpener === undefined ? 2 : 1;
+    if (opener === undefined ||
+        !DEICTIC_OPENERS.has(opener) ||
+        (contractedOpener === undefined &&
+            !["is", "was"].includes(words[1] ?? "")) ||
+        !["a", "an", "the"].includes(words[determinerIndex] ?? "")) {
+        return undefined;
+    }
+    const adjective = words[determinerIndex + 1];
+    const noun = words[determinerIndex + 2];
+    const frame = adjective !== undefined && noun !== undefined
+        ? words.slice(0, determinerIndex + 3).join(" ")
+        : undefined;
+    const boundary = frame === undefined ? undefined : text.at(frame.length);
+    return adjective !== undefined &&
+        noun !== undefined &&
+        (boundary === undefined ||
+            boundary === "." ||
+            boundary === "!" ||
+            boundary === "?" ||
+            boundary === ":" ||
+            boundary === ";" ||
+            boundary === ",") &&
+        DEICTIC_EVALUATIVE_ADJECTIVES.has(adjective) &&
+        DEICTIC_DISCOURSE_NOUNS.has(noun)
+        ? `deictic-evaluative-${opener}-${adjective}-${noun}`
+        : undefined;
+}
 export function isAbstractAuditFrame(words) {
     return words[0] === "the" && frameNounIndex(words) > 0
         ? words[frameNounIndex(words)] === "audit"
         : false;
 }
-export function matchExpandedDiscourseFrame(words) {
-    return (matchWorthAttentionFrame(words) ??
+export function matchExpandedDiscourseFrame(text, words) {
+    return (matchDeicticEvaluativeFrame(text, words) ??
+        matchWorthAttentionFrame(words) ??
         matchVagueFrameLocation(words) ??
         matchEvaluativeFrame(words));
 }

package/dist/rules/words/actually-overuse.js

@@ -1,7 +1,5 @@
-import { defineTextlintRule } from "../../adapters/textlint/rule.js";
-import { documentUnit } from "../../adapters/textlint/units.js";
 import { ERROR_SEVERITY } from "../../reporting/density.js";
-import { wordTokens } from "../../shared/text/tokens.js";
+import { defineExactTokenDensityRule } from "./private/token-density-rule.js";
 // The rule only detects occurrences of "actually" - one detection per use, no counting,
 // rate, or severity. The density-rate report policy below lets the reporter judge the
 // occurrences against the document word count and decide none / warning / error.
@@ -9,20 +7,8 @@ import { wordTokens } from "../../shared/text/tokens.js";
 // density, which is the reporter's concern, not the detector's. See src/reporting/density.ts.
 const TARGET = "actually";
 const RULE_ID = "words:actually-overuse";
-const rule = defineTextlintRule({
-    detector: {
-        detect: ({ units }) => units.flatMap((unit) => wordTokens(unit.text)
-            .filter((token) => token.normalized === TARGET)
-            .map((token) => ({
-            evidence: TARGET,
-            label: TARGET,
-            range: { end: token.end, start: token.start },
-            ruleId: RULE_ID,
-            unitId: unit.id
-        }))),
-        family: "words",
-        id: RULE_ID
-    },
+const rule = defineExactTokenDensityRule({
+    errorPerUnit: 2,
     formatMessage: (report) => {
         const count = report.metric?.["count"] ?? report.detections.length;
         const perUnit = report.metric?.["perUnit"] ?? 0;
@@ -31,15 +17,11 @@ const rule = defineTextlintRule({
             : "above the 1-per-1,000-word warning threshold";
         return `"actually" used ${count} times (${perUnit} per 1,000 words), ${threshold}. Cut the filler uses; keep at most about one per 1,000 words.`;
     },
-    reportPolicy: {
-        errorPerUnit: 2,
-        kind: "density-rate",
-        minimumOccurrences: 2,
-        scope: "document",
-        warningPerUnit: 1,
-        wordsPerUnit: 1000
-    },
-    units: (document) => [documentUnit(document)]
+    minimumOccurrences: 2,
+    ruleId: RULE_ID,
+    target: TARGET,
+    warningPerUnit: 1,
+    wordsPerUnit: 1000
 });
 export default rule;
 //# sourceMappingURL=actually-overuse.js.map

package/dist/rules/words/private/token-density-rule.js

@@ -0,0 +1,31 @@
+import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
+import { documentUnit } from "../../../adapters/textlint/units.js";
+import { wordTokens } from "../../../shared/text/tokens.js";
+export function defineExactTokenDensityRule(config) {
+    return defineTextlintRule({
+        detector: {
+            detect: ({ units }) => units.flatMap((unit) => wordTokens(unit.text)
+                .filter((token) => token.normalized === config.target)
+                .map((token) => ({
+                evidence: config.target,
+                label: config.target,
+                range: { end: token.end, start: token.start },
+                ruleId: config.ruleId,
+                unitId: unit.id
+            }))),
+            family: "words",
+            id: config.ruleId
+        },
+        formatMessage: config.formatMessage,
+        reportPolicy: {
+            errorPerUnit: config.errorPerUnit,
+            kind: "density-rate",
+            minimumOccurrences: config.minimumOccurrences,
+            scope: "document",
+            warningPerUnit: config.warningPerUnit,
+            wordsPerUnit: config.wordsPerUnit
+        },
+        units: (document) => [documentUnit(document)]
+    });
+}
+//# sourceMappingURL=token-density-rule.js.map

package/dist/rules/words/quietly-overuse.js

@@ -0,0 +1,22 @@
+import { ERROR_SEVERITY } from "../../reporting/density.js";
+import { defineExactTokenDensityRule } from "./private/token-density-rule.js";
+const TARGET = "quietly";
+const RULE_ID = "words:quietly-overuse";
+const rule = defineExactTokenDensityRule({
+    errorPerUnit: 2,
+    formatMessage: (report) => {
+        const count = report.metric?.["count"] ?? report.detections.length;
+        const perUnit = report.metric?.["perUnit"] ?? 0;
+        const threshold = report.severity === ERROR_SEVERITY
+            ? "above the 2-per-1,000-word error threshold"
+            : "above the 1-per-1,000-word warning threshold";
+        return `"quietly" used ${count} times (${perUnit} per 1,000 words), ${threshold}. Cut the filler uses; keep at most about one per 1,000 words.`;
+    },
+    minimumOccurrences: 4,
+    ruleId: RULE_ID,
+    target: TARGET,
+    warningPerUnit: 1,
+    wordsPerUnit: 1000
+});
+export default rule;
+//# sourceMappingURL=quietly-overuse.js.map

package/dist/shared/text/document.js

@@ -1,8 +1,43 @@
 import { allParagraphs } from "./sections.js";
+function trimStartLength(text) {
+    return text.length - text.trimStart().length;
+}
+export function documentSourceText(document) {
+    const paragraphs = [];
+    const textParts = [];
+    let outputStart = 0;
+    for (const paragraph of allParagraphs(document)) {
+        const text = paragraph.text.trim();
+        if (text.length === 0) {
+            continue;
+        }
+        paragraphs.push({
+            outputEnd: outputStart + text.length,
+            outputStart,
+            paragraph,
+            trimStart: trimStartLength(paragraph.text)
+        });
+        textParts.push(text);
+        outputStart += text.length + 2;
+    }
+    const originalOffsetFor = (offset, isEnd) => {
+        const mapped = paragraphs.find((paragraph) => offset >= paragraph.outputStart && offset <= paragraph.outputEnd);
+        if (mapped === undefined) {
+            return offset;
+        }
+        const paragraphOffset = mapped.trimStart + offset - mapped.outputStart;
+        const localOffset = isEnd
+            ? mapped.paragraph.source.originalEndFor(paragraphOffset)
+            : mapped.paragraph.source.originalStartFor(paragraphOffset);
+        return mapped.paragraph.paragraph.range[0] + localOffset;
+    };
+    return {
+        originalEndFor: (end) => originalOffsetFor(end, true),
+        originalStartFor: (start) => originalOffsetFor(start, false),
+        text: textParts.join("\n\n")
+    };
+}
 export function documentText(document) {
-    return allParagraphs(document)
-        .map((paragraph) => paragraph.text.trim())
-        .filter((text) => text.length > 0)
-        .join("\n\n");
+    return documentSourceText(document).text;
 }
 //# sourceMappingURL=document.js.map

package/dist/shared/text/sections.js

@@ -1,26 +1,11 @@
 import { splitSentences } from "./sentences.js";
-import { sourceText } from "./traverse.js";
+import { proseSourceText, sourceText } from "./traverse.js";
 function isParagraphNode(node) {
     return node.type === "Paragraph";
 }
 function isParentNode(node) {
     return "children" in node;
 }
-function hasStringValue(node) {
-    return "value" in node && typeof node.value === "string";
-}
-function plainText(node) {
-    if (hasStringValue(node)) {
-        return node.value;
-    }
-    if (node.type === "Break") {
-        return " ";
-    }
-    if (!isParentNode(node)) {
-        return "";
-    }
-    return node.children.map((child) => plainText(child)).join("");
-}
 function collectParagraphs(node, paragraphs) {
     if (isParagraphNode(node)) {
         paragraphs.push(node);
@@ -79,10 +64,11 @@ export function allParagraphs(document) {
     const paragraphs = [];
     for (const section of documentSections(document)) {
         for (const paragraph of sectionParagraphs(section)) {
+            const source = proseSourceText(paragraph);
             paragraphs.push({
                 paragraph,
-                source: sourceText(paragraph),
-                text: plainText(paragraph)
+                source,
+                text: source.text
             });
         }
     }

package/dist/shared/text/traverse.js

@@ -1,13 +1,58 @@
 import { StringSource } from "textlint-util-to-string";
-export function sourceText(node) {
+function isParentNode(node) {
+    return "children" in node;
+}
+function isHtmlNode(node) {
+    return (node.type === "Html" && "value" in node && typeof node.value === "string");
+}
+function normalizeNode(node, includeImageAlt) {
+    if (node.type === "Break") {
+        return {
+            ...node,
+            type: "Str",
+            value: " "
+        };
+    }
+    if ((node.type === "Image" || node.type === "ImageReference") &&
+        !includeImageAlt) {
+        return {
+            ...node,
+            type: "Str",
+            value: ""
+        };
+    }
+    if (isHtmlNode(node) && !includeImageAlt) {
+        return {
+            ...node,
+            type: "Str",
+            value: node.value
+        };
+    }
+    if (!isParentNode(node)) {
+        return node;
+    }
+    return {
+        ...node,
+        // type-coverage:ignore-next-line
+        children: node.children.map((child) => normalizeNode(child, includeImageAlt))
+    };
+}
+function mappedSourceText(node, includeImageAlt) {
     // textlint-util-to-string has not updated its public type for textlint 15.7's
     // readonly children, but it only reads the node at runtime.
-    const source = new StringSource(node // type-coverage:ignore-line
-    );
+    const source = new StringSource(
+    // type-coverage:ignore-next-line
+    normalizeNode(node, includeImageAlt));
     return {
         originalEndFor: (end) => source.originalIndexFromIndex(end, true) ?? end,
         originalStartFor: (start) => source.originalIndexFromIndex(start) ?? start,
         text: source.toString()
     };
 }
+export function proseSourceText(node) {
+    return mappedSourceText(node, false);
+}
+export function sourceText(node) {
+    return mappedSourceText(node, true);
+}
 //# sourceMappingURL=traverse.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",
@@ -111,7 +111,8 @@
     "./rules/words/llm-vocabulary-density": "./dist/rules/words/llm-vocabulary-density.js",
     "./rules/words/llm-vocabulary": "./dist/rules/words/llm-vocabulary.js",
     "./rules/words/simplicity": "./dist/rules/words/simplicity.js",
-    "./rules/words/prohibited-words": "./dist/rules/words/prohibited-words.js"
+    "./rules/words/prohibited-words": "./dist/rules/words/prohibited-words.js",
+    "./rules/words/quietly-overuse": "./dist/rules/words/quietly-overuse.js"
   },
   "dependencies": {
     "@textlint/ast-node-types": "15.7.1",