slopless 0.2.27 → 0.2.29

package/dist/rules/words/private/quietly-clause.js

@@ -0,0 +1,60 @@
+const BOUNDARY_WORDS = new Set([
+    "after",
+    "although",
+    "because",
+    "before",
+    "but",
+    "if",
+    "once",
+    "since",
+    "so",
+    "that",
+    "though",
+    "unless",
+    "when",
+    "whenever",
+    "where",
+    "whereas",
+    "while",
+    "which",
+    "who"
+]);
+function hasBoundaryPunctuation(text, left, right) {
+    const between = text.slice(left.end, right.start);
+    return (between.includes(";") ||
+        between.includes(":") ||
+        between.includes(".") ||
+        between.includes("!") ||
+        between.includes("?"));
+}
+export function quietlyClauseFor(text, tokens, index) {
+    let start = 0;
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        const token = tokens[cursor];
+        const next = tokens[cursor + 1];
+        if (token === undefined ||
+            next === undefined ||
+            BOUNDARY_WORDS.has(token.normalized) ||
+            hasBoundaryPunctuation(text, token, next)) {
+            start = cursor + 1;
+            break;
+        }
+    }
+    let end = tokens.length;
+    for (let cursor = index + 1; cursor < tokens.length; cursor += 1) {
+        const previous = tokens[cursor - 1];
+        const token = tokens[cursor];
+        if (previous === undefined ||
+            token === undefined ||
+            BOUNDARY_WORDS.has(token.normalized) ||
+            hasBoundaryPunctuation(text, previous, token)) {
+            end = cursor;
+            break;
+        }
+    }
+    return {
+        index: index - start,
+        tokens: tokens.slice(start, end)
+    };
+}
+//# sourceMappingURL=quietly-clause.js.map

package/dist/rules/words/private/quietly-context.js

@@ -0,0 +1,163 @@
+import { wordTokens } from "../../../shared/text/tokens.js";
+import quietlyContextVocabulary from "../data/quietly-context.json" with { type: "json" };
+import { quietlyClauseFor } from "./quietly-clause.js";
+import { hasDetachedCompanion, hasInformativeChangeEvidence, hasLinkedTechnicalEvidence, hasSpecifiedTechnicalEvidence } from "./quietly-evidence.js";
+const TARGET = "quietly";
+const DETACHED_EXPLANATION_WORDS = new Set(quietlyContextVocabulary.detachedExplanationWords);
+const DETACHED_RESULT_WORDS = new Set(quietlyContextVocabulary.detachedResultWords);
+const AUXILIARIES = new Set(quietlyContextVocabulary.auxiliaries);
+const EVALUATIVE_WORDS = new Set(quietlyContextVocabulary.evaluativeWords);
+const ABSTRACT_CHANGE_WORDS = new Set(quietlyContextVocabulary.abstractChangeWords);
+const STRONG_ABSTRACT_CHANGE_WORDS = new Set(quietlyContextVocabulary.strongAbstractChangeWords);
+const ABSTRACT_SUBJECT_WORDS = new Set(quietlyContextVocabulary.abstractSubjectWords);
+const HIDDEN_HARM_WORDS = new Set(quietlyContextVocabulary.hiddenHarmWords);
+const BACKGROUND_ACTION_WORDS = new Set(quietlyContextVocabulary.backgroundActionWords);
+const BACKGROUND_SIGNIFICANCE_WORDS = new Set(quietlyContextVocabulary.backgroundSignificanceWords);
+const TREND_ACTION_WORDS = new Set(quietlyContextVocabulary.trendActionWords);
+const TREND_SUBJECT_WORDS = new Set(quietlyContextVocabulary.trendSubjectWords);
+const TITLE_CONTEXT_WORDS = new Set(quietlyContextVocabulary.titleContextWords);
+const NORMAL_MANNER_WORDS = new Set(quietlyContextVocabulary.normalMannerWords);
+const PRIVATE_ACTION_WORDS = new Set(quietlyContextVocabulary.privateActionWords);
+const SPECIFIED_TECHNICAL_WORDS = new Set(quietlyContextVocabulary.specifiedTechnicalWords);
+function containsAny(words, candidates) {
+    return words.some((word) => candidates.has(word));
+}
+function governingWords(tokens, index) {
+    const words = [];
+    const after = nextMeaningfulWord(tokens, index);
+    if (after !== undefined) {
+        words.push(after);
+    }
+    for (let cursor = index - 1; cursor >= Math.max(0, index - 3); cursor -= 1) {
+        const word = tokens[cursor]?.normalized;
+        if (word === undefined || AUXILIARIES.has(word)) {
+            break;
+        }
+        words.push(word);
+    }
+    return words;
+}
+function wordsNear(tokens, index, radius) {
+    return tokens
+        .slice(Math.max(0, index - radius), index + radius + 1)
+        .map((token) => token.normalized);
+}
+function matchesPairGroup(localWords, allWords, groups) {
+    return groups.some(({ actions, markers }) => actions.some((word) => localWords.includes(word)) &&
+        markers.some((word) => allWords.includes(word)));
+}
+function matchesRequiredPairGroup(localWords, allWords, groups) {
+    return groups.some(({ actions, markers }) => actions.some((word) => localWords.includes(word)) &&
+        markers.every((word) => allWords.includes(word)));
+}
+function isFirstPersonBuild(tokens, index, localWords, sentenceWords) {
+    const before = tokens.slice(0, index).map((token) => token.normalized);
+    return (containsAny(localWords, TREND_ACTION_WORDS) &&
+        containsAny(sentenceWords, TREND_SUBJECT_WORDS) &&
+        (before.includes("i") ||
+            before.includes("i've") ||
+            before.includes("my") ||
+            before.includes("we") ||
+            before.includes("we've")));
+}
+function nextMeaningfulWord(tokens, index) {
+    for (let cursor = index + 1; cursor < tokens.length; cursor += 1) {
+        const word = tokens[cursor]?.normalized;
+        if (word !== undefined && !AUXILIARIES.has(word)) {
+            return word;
+        }
+    }
+    return undefined;
+}
+function isAbstractChangeContext(tokens, index, localWords, contextWords, sentenceWords, sentenceTokens, sentenceIndex) {
+    const hasChangePattern = containsAny(localWords, STRONG_ABSTRACT_CHANGE_WORDS) ||
+        (containsAny(localWords, ABSTRACT_CHANGE_WORDS) &&
+            containsAny(contextWords, ABSTRACT_SUBJECT_WORDS)) ||
+        matchesRequiredPairGroup(localWords, sentenceWords, quietlyContextVocabulary.abstractChangePairGroups);
+    return (hasChangePattern &&
+        !hasInformativeChangeEvidence(tokens, index, sentenceTokens, sentenceIndex));
+}
+function isNormalUse(text, tokens, index, label, sentenceTokens, sentenceIndex) {
+    const allWords = tokens.map((token) => token.normalized);
+    if (containsAny(wordsNear(tokens, index, 5), TITLE_CONTEXT_WORDS)) {
+        return true;
+    }
+    const localWords = governingWords(tokens, index);
+    if ((label === undefined && containsAny(localWords, NORMAL_MANNER_WORDS)) ||
+        containsAny(localWords, PRIVATE_ACTION_WORDS)) {
+        return true;
+    }
+    return (containsAny(localWords, SPECIFIED_TECHNICAL_WORDS) &&
+        (hasSpecifiedTechnicalEvidence(allWords) ||
+            hasLinkedTechnicalEvidence(text, sentenceTokens, sentenceIndex)));
+}
+function contextClassFor(text, tokens, index, sentenceTokens, sentenceIndex) {
+    const words = tokens.map((token) => token.normalized);
+    const sentenceWords = sentenceTokens.map((token) => token.normalized);
+    if (sentenceTokens.length === 1) {
+        return "detached-emphasis";
+    }
+    if (hasDetachedCompanion(text, tokens, index) &&
+        (tokens.length <= 8 || containsAny(words, DETACHED_EXPLANATION_WORDS))) {
+        return "detached-emphasis";
+    }
+    const localWords = governingWords(tokens, index);
+    const contextWords = wordsNear(tokens, index, 5);
+    const token = tokens[index];
+    const isTrailingResult = token !== undefined &&
+        containsAny(localWords, DETACHED_RESULT_WORDS) &&
+        (index === tokens.length - 1 ||
+            text.slice(token.end).trimStart().startsWith(":"));
+    if (isTrailingResult) {
+        return "detached-emphasis";
+    }
+    const nextWord = nextMeaningfulWord(tokens, index);
+    if (nextWord !== undefined && EVALUATIVE_WORDS.has(nextWord)) {
+        return "evaluative-intensifier";
+    }
+    if (containsAny(localWords, HIDDEN_HARM_WORDS) ||
+        matchesPairGroup(localWords, wordsNear(tokens, index, 8), quietlyContextVocabulary.hiddenHarmPairGroups)) {
+        return "hidden-harm";
+    }
+    if (isAbstractChangeContext(tokens, index, localWords, contextWords, words, sentenceTokens, sentenceIndex)) {
+        return "abstract-change";
+    }
+    if (containsAny(localWords, BACKGROUND_ACTION_WORDS) &&
+        containsAny(contextWords, BACKGROUND_SIGNIFICANCE_WORDS)) {
+        return "background-significance";
+    }
+    if (matchesRequiredPairGroup(localWords, words, quietlyContextVocabulary.backgroundPhraseGroups)) {
+        return "background-significance";
+    }
+    if ((containsAny(words, TREND_SUBJECT_WORDS) &&
+        (containsAny(localWords, TREND_ACTION_WORDS) ||
+            (index <= 2 && containsAny(words, TREND_ACTION_WORDS)))) ||
+        isFirstPersonBuild(tokens, index, localWords, sentenceWords) ||
+        matchesRequiredPairGroup(localWords, words, quietlyContextVocabulary.trendPhraseGroups)) {
+        return "unannounced-trend";
+    }
+    return undefined;
+}
+export function findQuietlyContextMatches(text) {
+    const tokens = wordTokens(text);
+    const matches = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token?.normalized !== TARGET) {
+            continue;
+        }
+        const clause = quietlyClauseFor(text, tokens, index);
+        const label = contextClassFor(text, clause.tokens, clause.index, tokens, index);
+        if (label === undefined ||
+            isNormalUse(text, clause.tokens, clause.index, label, tokens, index)) {
+            continue;
+        }
+        matches.push({
+            evidence: token.text,
+            label,
+            range: { end: token.end, start: token.start }
+        });
+    }
+    return matches;
+}
+//# sourceMappingURL=quietly-context.js.map

package/dist/rules/words/private/quietly-evidence.js

@@ -0,0 +1,68 @@
+import quietlyContextVocabulary from "../data/quietly-context.json" with { type: "json" };
+const ABSTRACT_CHANGE_WORDS = new Set(quietlyContextVocabulary.abstractChangeWords);
+const STRONG_ABSTRACT_CHANGE_WORDS = new Set(quietlyContextVocabulary.strongAbstractChangeWords);
+const DETACHED_COMPANION_WORDS = new Set(quietlyContextVocabulary.detachedCompanionWords);
+const TECHNICAL_EVIDENCE_WORDS = new Set(quietlyContextVocabulary.technicalEvidenceWords);
+function startsWithDigit(word) {
+    const first = word.at(0);
+    return first !== undefined && first >= "0" && first <= "9";
+}
+export function hasSpecifiedTechnicalEvidence(words) {
+    const evidenceCount = words.filter((word) => TECHNICAL_EVIDENCE_WORDS.has(word)).length;
+    return (words.some(startsWithDigit) ||
+        words.includes("because") ||
+        evidenceCount >= 2);
+}
+export function hasLinkedTechnicalEvidence(text, tokens, index) {
+    const following = tokens.slice(index + 1);
+    const boundaryIndex = following.findIndex((token) => ["after", "because", "when"].includes(token.normalized));
+    const quietToken = tokens[index];
+    const colonIndex = quietToken === undefined ? -1 : text.indexOf(":", quietToken.end);
+    const evidence = boundaryIndex >= 0
+        ? following.slice(boundaryIndex + 1)
+        : colonIndex >= 0
+            ? following.filter((token) => token.start > colonIndex)
+            : [];
+    return ((following[boundaryIndex]?.normalized === "because" &&
+        evidence.length >= 3) ||
+        hasSpecifiedTechnicalEvidence(evidence.map((token) => token.normalized)));
+}
+export function hasDetachedCompanion(text, tokens, index) {
+    const companion = tokens
+        .slice(0, index)
+        .findLast((token) => DETACHED_COMPANION_WORDS.has(token.normalized));
+    const target = tokens[index];
+    return (companion !== undefined &&
+        target !== undefined &&
+        text.slice(companion.end, target.start).includes(","));
+}
+export function hasInformativeChangeEvidence(clauseTokens, clauseIndex, sentenceTokens, sentenceIndex) {
+    const clauseWords = clauseTokens.map((token) => token.normalized);
+    if (clauseWords.includes("from") && clauseWords.includes("to")) {
+        return true;
+    }
+    const actionIndices = clauseWords.flatMap((word, index) => ABSTRACT_CHANGE_WORDS.has(word) || STRONG_ABSTRACT_CHANGE_WORDS.has(word)
+        ? [index]
+        : []);
+    const actionIndex = actionIndices.reduce((nearest, candidate) => nearest === undefined ||
+        Math.abs(candidate - clauseIndex) < Math.abs(nearest - clauseIndex)
+        ? candidate
+        : nearest, undefined);
+    if (actionIndex !== undefined &&
+        clauseWords.slice(actionIndex + 1, actionIndex + 7).some(startsWithDigit)) {
+        return true;
+    }
+    if (actionIndex === undefined) {
+        return false;
+    }
+    const sentenceActionIndex = sentenceTokens.findIndex((token) => token.start === clauseTokens[actionIndex]?.start);
+    if (sentenceActionIndex < 0) {
+        return false;
+    }
+    const explanation = sentenceTokens.slice(sentenceActionIndex + 1);
+    const boundaryIndex = explanation.findIndex((token) => token.normalized === "after" || token.normalized === "because");
+    return (sentenceActionIndex <= sentenceIndex &&
+        boundaryIndex >= 0 &&
+        explanation.length - boundaryIndex > 4);
+}
+//# sourceMappingURL=quietly-evidence.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-filler.js

@@ -0,0 +1,21 @@
+import { oneToOneRule } from "../private/textlint-rule-builders.js";
+import { findQuietlyContextMatches } from "./private/quietly-context.js";
+const RULE_ID = "words:quietly-filler";
+const rule = oneToOneRule({
+    detect: (unit) => findQuietlyContextMatches(unit.text).map((match) => ({
+        data: { contextClass: match.label },
+        evidence: match.evidence,
+        label: match.label,
+        range: match.range
+    })),
+    family: "words",
+    formatMessage: (report) => {
+        const contextClass = report.detections[0]?.data?.["contextClass"];
+        return `"quietly" adds vague hidden significance (${contextClass}). Name the concrete change or remove the adverb.`;
+    },
+    ruleId: RULE_ID,
+    severity: 1,
+    unitKind: "sentence"
+});
+export default rule;
+//# sourceMappingURL=quietly-filler.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";
+import { allDocumentParagraphs } 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 allDocumentParagraphs(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,27 +1,24 @@
 import { splitSentences } from "./sentences.js";
-import { sourceText } from "./traverse.js";
+import { proseSourceText } 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 " ";
+function collectRuleParagraphs(node, paragraphs) {
+    if (isParagraphNode(node)) {
+        paragraphs.push(node);
+        return;
     }
     if (!isParentNode(node)) {
-        return "";
+        return;
+    }
+    for (const child of node.children) {
+        collectRuleParagraphs(child, paragraphs);
     }
-    return node.children.map((child) => plainText(child)).join("");
 }
-function collectParagraphs(node, paragraphs) {
+function collectDocumentParagraphs(node, paragraphs) {
     if (isParagraphNode(node)) {
         paragraphs.push(node);
         return;
@@ -30,13 +27,20 @@ function collectParagraphs(node, paragraphs) {
         return;
     }
     for (const child of node.children) {
-        collectParagraphs(child, paragraphs);
+        collectDocumentParagraphs(child, paragraphs);
     }
 }
-function sectionParagraphs(section) {
+function sectionRuleParagraphs(section) {
     const paragraphs = [];
     for (const node of section) {
-        collectParagraphs(node, paragraphs);
+        collectRuleParagraphs(node, paragraphs);
+    }
+    return paragraphs;
+}
+function sectionDocumentParagraphs(section) {
+    const paragraphs = [];
+    for (const node of section) {
+        collectDocumentParagraphs(node, paragraphs);
     }
     return paragraphs;
 }
@@ -59,7 +63,7 @@ function documentSections(document) {
     return sections;
 }
 function paragraphSentences(paragraph) {
-    const source = sourceText(paragraph);
+    const source = proseSourceText(paragraph);
     return splitSentences(source.text).map((sentence) => ({
         paragraph,
         sentence,
@@ -69,29 +73,36 @@ function paragraphSentences(paragraph) {
 export function allParagraphSentences(document) {
     const sentences = [];
     for (const section of documentSections(document)) {
-        for (const paragraph of sectionParagraphs(section)) {
+        for (const paragraph of sectionRuleParagraphs(section)) {
             sentences.push(...paragraphSentences(paragraph));
         }
     }
     return sentences;
 }
-export function allParagraphs(document) {
+function mappedParagraphs(document, select) {
     const paragraphs = [];
     for (const section of documentSections(document)) {
-        for (const paragraph of sectionParagraphs(section)) {
+        for (const paragraph of select(section)) {
+            const source = proseSourceText(paragraph);
             paragraphs.push({
                 paragraph,
-                source: sourceText(paragraph),
-                text: plainText(paragraph)
+                source,
+                text: source.text
             });
         }
     }
     return paragraphs;
 }
+export function allDocumentParagraphs(document) {
+    return mappedParagraphs(document, sectionDocumentParagraphs);
+}
+export function allParagraphs(document) {
+    return mappedParagraphs(document, sectionRuleParagraphs);
+}
 export function sectionFirstSentences(document) {
     const sentences = [];
     for (const section of documentSections(document)) {
-        const firstParagraph = sectionParagraphs(section).at(0);
+        const firstParagraph = sectionRuleParagraphs(section).at(0);
         if (firstParagraph === undefined) {
             continue;
         }
@@ -105,7 +116,7 @@ export function sectionFirstSentences(document) {
 export function sectionLastSentences(document) {
     const sentences = [];
     for (const section of documentSections(document)) {
-        const lastParagraph = sectionParagraphs(section).at(-1);
+        const lastParagraph = sectionRuleParagraphs(section).at(-1);
         if (lastParagraph === undefined) {
             continue;
         }

package/dist/shared/text/traverse.js

@@ -1,13 +1,67 @@
 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) {
+        const alt = "alt" in node && typeof node.alt === "string" ? node.alt : "";
+        return {
+            ...node,
+            type: "Str",
+            value: " ".repeat(alt.length)
+        };
+    }
+    if (node.type === "Code" && !includeImageAlt) {
+        const value = "value" in node && typeof node.value === "string" ? node.value : "";
+        return {
+            ...node,
+            type: "Str",
+            value: " ".repeat(value.length)
+        };
+    }
+    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.27",
+  "version": "0.2.29",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",
@@ -111,7 +111,9 @@
     "./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-filler": "./dist/rules/words/quietly-filler.js",
+    "./rules/words/quietly-overuse": "./dist/rules/words/quietly-overuse.js"
   },
   "dependencies": {
     "@textlint/ast-node-types": "15.7.1",