slopless 0.2.22 → 0.2.24

package/dist/rules/syntactic-patterns/contrast/private/reframe-classification.js

@@ -0,0 +1,193 @@
+import { FACTUAL_NEGATION_CONNECTORS, findCopularNegation, pronounCopulaStart, stripLeadingPairPivot, words } from "./negation-reframe-parts.js";
+const FRAMING_SUBJECT_NOUNS = new Set([
+    "answer",
+    "fix",
+    "goal",
+    "issue",
+    "key",
+    "point",
+    "problem",
+    "solution",
+    "strategy"
+]);
+const INSTRUCTION_ADJECTIVES = new Set([
+    "best",
+    "better",
+    "critical",
+    "essential",
+    "important",
+    "necessary",
+    "recommended",
+    "safest"
+]);
+const CONCRETE_PASSIVE_VERBS = new Set([
+    "associated",
+    "caused",
+    "classified",
+    "created",
+    "entered",
+    "linked",
+    "owned",
+    "paid",
+    "passed",
+    "produced",
+    "recorded",
+    "regulated",
+    "sent",
+    "stored",
+    "used"
+]);
+const REFERENCE_PASSIVE_VERBS = new Set(["defined", "described", "marked"]);
+const PASSIVE_EXPLANATION_LINKS = new Set([
+    "as",
+    "by",
+    "for",
+    "from",
+    "in",
+    "to",
+    "with"
+]);
+const CLAUSE_BOUNDARIES = new Set([
+    "and",
+    "but",
+    "that",
+    "when",
+    "where",
+    "which",
+    "while"
+]);
+const CONCRETE_RELATIONS = [
+    ["amount", "of"],
+    ["defined", "to", "be"],
+    ["derived", "from"],
+    ["intended", "for"],
+    ["owned", "by"],
+    ["property", "of"],
+    ["symptom", "of"],
+    ["unit", "of"]
+];
+const MAX_SHORT_SENTENCE_WORDS = 6;
+const QUANTITY_WORDS = new Set([
+    "half",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten"
+]);
+function digitTokenCount(tokens) {
+    return tokens.filter((token) => [...token.text].some((character) => character >= "0" && character <= "9")).length;
+}
+function quantityTokenCount(tokens) {
+    return (digitTokenCount(tokens) +
+        tokens.filter((token) => QUANTITY_WORDS.has(token.normalized)).length);
+}
+function acronymCount(tokens) {
+    return tokens.filter((token) => token.text.length >= 2 &&
+        token.text === token.text.toLocaleUpperCase("en") &&
+        token.text !== token.text.toLocaleLowerCase("en")).length;
+}
+function properNameCount(tokens) {
+    return tokens.filter((token, index) => {
+        const first = token.text[0];
+        return (index > 0 &&
+            first !== undefined &&
+            first >= "A" &&
+            first <= "Z" &&
+            token.text !== token.text.toLocaleUpperCase("en"));
+    }).length;
+}
+function hasReferenceEvidence(aTokens, bTokens, pairText) {
+    const digits = digitTokenCount(aTokens) + digitTokenCount(bTokens);
+    const quantities = quantityTokenCount(aTokens) + quantityTokenCount(bTokens);
+    const names = properNameCount(aTokens) + properNameCount(bTokens);
+    return (digits >= 2 ||
+        pairText.includes("/") ||
+        pairText.includes("_") ||
+        pairText.includes("@") ||
+        (acronymCount(aTokens) + acronymCount(bTokens) >= 1 && digits >= 1) ||
+        names >= 3 ||
+        (names >= 2 && quantities >= 1));
+}
+function startsWithSequence(source, sequence) {
+    return sequence.every((word, index) => source[index] === word);
+}
+function containsSequence(source, sequence) {
+    for (let index = 0; index <= source.length - sequence.length; index += 1) {
+        if (startsWithSequence(source.slice(index), sequence)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasConcreteRelation(tokenWords) {
+    return CONCRETE_RELATIONS.some((relation) => containsSequence(tokenWords, relation));
+}
+function hasInstruction(tokens) {
+    const tokenWords = words(tokens);
+    const start = pronounCopulaStart(tokens);
+    return (start !== undefined &&
+        INSTRUCTION_ADJECTIVES.has(tokenWords[start.predicateStart] ?? "") &&
+        tokenWords[start.predicateStart + 1] === "to");
+}
+function hasPassiveExplanation(bTokens) {
+    const tokenWords = words(bTokens);
+    const start = pronounCopulaStart(bTokens);
+    const isConcretePassive = (word) => CONCRETE_PASSIVE_VERBS.has(word) || REFERENCE_PASSIVE_VERBS.has(word);
+    if (start !== undefined &&
+        isConcretePassive(tokenWords[start.predicateStart] ?? "")) {
+        return true;
+    }
+    const boundary = tokenWords.findIndex((word) => CLAUSE_BOUNDARIES.has(word));
+    const firstClause = boundary < 0 ? tokenWords : tokenWords.slice(0, boundary);
+    return firstClause.some((word, index) => isConcretePassive(word) &&
+        PASSIVE_EXPLANATION_LINKS.has(firstClause[index + 1] ?? ""));
+}
+function hasPurposeOrProvenance(tokenWords) {
+    return (containsSequence(tokenWords, ["used", "to"]) ||
+        (["uses", "used"].includes(tokenWords[1] ?? "") &&
+            tokenWords.some((word, index) => ["created", "produced"].includes(word) &&
+                ["by", "from", "in"].includes(tokenWords[index + 1] ?? ""))));
+}
+function hasCausalPassiveExplanation(aTokens, bTokens) {
+    return (words(aTokens).some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        hasPassiveExplanation(bTokens));
+}
+function hasDistinctCauseExplanation(aTokens, bTokens) {
+    const aWords = words(aTokens);
+    const bWords = words(stripLeadingPairPivot(bTokens));
+    return (!aWords.includes("caused") && containsSequence(bWords, ["caused", "by"]));
+}
+function hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText) {
+    const tokenWords = words(stripLeadingPairPivot(bTokens));
+    return (hasInstruction(bTokens) ||
+        hasConcreteRelation(tokenWords) ||
+        hasPurposeOrProvenance(tokenWords) ||
+        hasDistinctCauseExplanation(aTokens, bTokens) ||
+        hasCausalPassiveExplanation(aTokens, bTokens) ||
+        (hasReferenceEvidence(aTokens, bTokens, pairText) &&
+            hasPassiveExplanation(bTokens)));
+}
+function hasFramingNoun(tokens) {
+    const negation = findCopularNegation(tokens);
+    if (negation === undefined) {
+        return false;
+    }
+    const predicate = words(tokens).slice(negation.negatedPredicateStart, negation.negatedPredicateStart + 4);
+    return [...negation.subject, ...predicate].some((word) => FRAMING_SUBJECT_NOUNS.has(word));
+}
+function isShortReversal(aTokens, bTokens) {
+    return (aTokens.length <= MAX_SHORT_SENTENCE_WORDS &&
+        bTokens.length <= MAX_SHORT_SENTENCE_WORDS);
+}
+export function shouldReportCopularReframe(aTokens, bTokens, pairText) {
+    return (isShortReversal(aTokens, bTokens) ||
+        hasFramingNoun(aTokens) ||
+        !hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText));
+}
+//# sourceMappingURL=reframe-classification.js.map

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

@@ -1,7 +1,7 @@
 import { hasConcreteImplementationSummary } from "../../../shared/matchers/concrete-evidence.js";
 import { cleanSentence, containsAny, tokens } from "../../../shared/matchers/prose-patterns.js";
 import { oneToOneRule } from "../../private/textlint-rule-builders.js";
-import { matchDiscourseEvaluationFrame } from "./private/discourse-evaluation.js";
+import { isAbstractAuditFrame, matchDiscourseEvaluationFrame, matchExpandedDiscourseFrame } from "./private/discourse-evaluation.js";
 const PREFIXES = ["however, ", "but ", "and ", "so "];
 // "as such" was removed: it is a normal anaphoric connective ("a registered adviser; as
 // such, it must...") and was the dominant false positive, not a signposting frame.
@@ -47,7 +47,6 @@ const FRAME_PATTERNS = [
     "the useful version is",
     "the point is plain enough"
 ];
-const DETERMINERS = ["a", "an", "the", "this", "that"];
 const SEQUENCE_PATTERNS = [
     "a simple sequence works well",
     "a simple pattern works well",
@@ -88,72 +87,9 @@ const WHAT_FRAME_TAIL_STARTERS = [
     "true",
     "usually"
 ];
-const FRAME_ADJECTIVES = [
-    "basic",
-    "best",
-    "better",
-    "biggest",
-    "bigger",
-    "central",
-    "clearest",
-    "core",
-    "easiest",
-    "final",
-    "first",
-    "hardest",
-    "honest",
-    "important",
-    "main",
-    "only",
-    "obvious",
-    "practical",
-    "real",
-    "simple",
-    "useful"
-];
-const FRAME_NOUNS = [
-    "answer",
-    "approach",
-    "challenge",
-    "choice",
-    "conclusion",
-    "fact",
-    "fix",
-    "focus",
-    "frame",
-    "idea",
-    "lesson",
-    "move",
-    "path",
-    "point",
-    "principle",
-    "priority",
-    "problem",
-    "question",
-    "result",
-    "rule",
-    "shift",
-    "signal",
-    "strategy",
-    "test",
-    "thing",
-    "tradeoff",
-    "truth",
-    "version",
-    "way",
-    "win"
-];
-const ABSTRACT_FRAME_VERBS = ["is", "are", "was"];
 const POINT_NOUNS = ["goal", "job", "key", "point", "takeaway", "trick"];
 function matchModifiedAbstractFrame(words) {
-    const [first, second, third, fourth, fifth] = words;
-    if (first === "the" &&
-        second === "result" &&
-        third === "worth" &&
-        fourth === "caring" &&
-        fifth === "about") {
-        return "the-result-worth-caring-about";
-    }
+    const [first, second, third, fourth] = words;
     if (first !== "the") {
         return undefined;
     }
@@ -167,20 +103,6 @@ function matchModifiedAbstractFrame(words) {
     ]);
     return matches.get(key);
 }
-function matchEvaluativeFrame(words) {
-    const [first, second, third, fourth] = words;
-    if (first !== undefined &&
-        second !== undefined &&
-        third !== undefined &&
-        fourth !== undefined &&
-        DETERMINERS.includes(first) &&
-        FRAME_ADJECTIVES.includes(second) &&
-        FRAME_NOUNS.includes(third) &&
-        ABSTRACT_FRAME_VERBS.includes(fourth)) {
-        return `the-${second}-${third}-${fourth}`;
-    }
-    return undefined;
-}
 function matchPointIsToFrame(words) {
     const [first, second, third, fourth, fifth] = words;
     if (first === "the" &&
@@ -217,8 +139,8 @@ function matchWhatFrame(words) {
 }
 function matchAbstractFrame(text) {
     const words = tokens(text);
-    return (matchModifiedAbstractFrame(words) ??
-        matchEvaluativeFrame(words) ??
+    return (matchExpandedDiscourseFrame(words) ??
+        matchModifiedAbstractFrame(words) ??
         matchDiscourseEvaluationFrame(words) ??
         matchPointIsToFrame(words) ??
         matchWhatFrame(words));
@@ -266,8 +188,14 @@ function matchGeneratedFormula(text) {
 }
 function matchSignposting(sentence) {
     const stripped = cleanSentence(sentence, PREFIXES);
-    const concreteImplementation = hasConcreteImplementationSummary(stripped);
     const abstract = matchAbstractFrame(stripped);
+    const strippedWords = tokens(stripped);
+    const auditStart = isAbstractAuditFrame(strippedWords)
+        ? stripped.indexOf("audit")
+        : -1;
+    const concreteImplementation = hasConcreteImplementationSummary(abstract !== undefined && auditStart >= 0
+        ? stripped.slice(0, auditStart) + stripped.slice(auditStart + 5)
+        : stripped);
     const formulaicSetup = matchFormulaicContentSetup(stripped);
     const generatedFormula = matchGeneratedFormula(stripped);
     if (abstract !== undefined && !concreteImplementation) {
@@ -279,6 +207,9 @@ function matchSignposting(sentence) {
     if (formulaicSetup !== undefined) {
         return { kind: "formulaic-content-setup", signal: formulaicSetup };
     }
+    if (stripped.startsWith("the fun part is:") && !concreteImplementation) {
+        return { kind: "frame-signpost", signal: "the fun part is:" };
+    }
     const checks = [
         ["transition", TRANSITION_PATTERNS],
         ["consultation-signpost", CONSULTATION_PATTERNS],

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

@@ -1,4 +1,74 @@
 const ABSTRACT_FRAME_VERBS = ["is", "are", "was", "were"];
+const DISCOURSE_WORK_TAILS = [
+    ["doing", "real", "work"],
+    ["load", "bearing"]
+];
+const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const FRAME_ADJECTIVES = new Set([
+    "basic",
+    "best",
+    "better",
+    "biggest",
+    "bigger",
+    "central",
+    "clearest",
+    "core",
+    "easiest",
+    "final",
+    "first",
+    "hardest",
+    "honest",
+    "important",
+    "main",
+    "only",
+    "obvious",
+    "practical",
+    "real",
+    "simple",
+    "useful"
+]);
+const FRAME_NOUNS = new Set([
+    "answer",
+    "approach",
+    "audit",
+    "challenge",
+    "choice",
+    "conclusion",
+    "diagnosis",
+    "fact",
+    "fix",
+    "focus",
+    "frame",
+    "idea",
+    "lesson",
+    "move",
+    "path",
+    "point",
+    "principle",
+    "priority",
+    "problem",
+    "question",
+    "result",
+    "rule",
+    "shift",
+    "signal",
+    "strategy",
+    "test",
+    "thing",
+    "tradeoff",
+    "truth",
+    "version",
+    "way",
+    "win"
+]);
+const VAGUE_FRAME_VERBS = new Set(["begins", "happens", "lives", "starts"]);
+const VAGUE_FRAME_LOCATIONS = new Set([
+    "downstream",
+    "earlier",
+    "here",
+    "there",
+    "upstream"
+]);
 const EVALUATION_TAILS = new Set([
     "boring",
     "clear",
@@ -72,15 +142,90 @@ function isDiscourseEvaluationSubject(first, subject) {
     }
     return subject.some((word) => DISCOURSE_SUBJECT_HEADS.has(word));
 }
-export function matchDiscourseEvaluationFrame(words) {
-    const [first] = words;
-    if (words.length > 8 ||
-        !["the", "this", "that", "it"].includes(first ?? "")) {
+function matchDiscourseWorkClaim(words, verbIndex, subject) {
+    if (verbIndex <= 0 ||
+        words[verbIndex] !== "is" ||
+        !DISCOURSE_SUBJECT_HEADS.has(subject.at(-1) ?? "")) {
+        return undefined;
+    }
+    const tail = DISCOURSE_WORK_TAILS.find((candidate) => candidate.every((word, index) => words[verbIndex + index + 1] === word));
+    return tail === undefined ? undefined : `is-${tail.join("-")}`;
+}
+function frameNounIndex(words) {
+    if (FRAME_NOUNS.has(words[1] ?? "")) {
+        return 1;
+    }
+    return FRAME_ADJECTIVES.has(words[1] ?? "") && FRAME_NOUNS.has(words[2] ?? "")
+        ? 2
+        : -1;
+}
+function matchWorthAttentionFrame(words) {
+    if (words[0] !== "the") {
         return undefined;
     }
+    const nounIndex = frameNounIndex(words);
+    if (nounIndex < 0 || words[nounIndex + 1] !== "worth") {
+        return undefined;
+    }
+    const tail = words.slice(nounIndex + 2);
+    const matches = tail[0] === "noticing" ||
+        tail[0] === "watching" ||
+        tail[0] === "tracking" ||
+        (tail[0] === "caring" && tail[1] === "about") ||
+        (tail[0] === "paying" && tail[1] === "attention" && tail[2] === "to");
+    return matches
+        ? `the-${words.slice(1, nounIndex + 1).join("-")}-worth-attention`
+        : undefined;
+}
+function matchVagueFrameLocation(words) {
+    const [first, adjective, noun, verb, location] = words;
+    return words.length === 5 &&
+        first === "the" &&
+        FRAME_ADJECTIVES.has(adjective ?? "") &&
+        FRAME_NOUNS.has(noun ?? "") &&
+        VAGUE_FRAME_VERBS.has(verb ?? "") &&
+        VAGUE_FRAME_LOCATIONS.has(location ?? "")
+        ? `the-${adjective ?? "useful"}-${noun ?? "frame"}-${verb ?? "starts"}-${location ?? "here"}`
+        : undefined;
+}
+function matchEvaluativeFrame(words) {
+    const [first, adjective, noun, verb] = words;
+    return first !== undefined &&
+        adjective !== undefined &&
+        noun !== undefined &&
+        verb !== undefined &&
+        DETERMINERS.has(first) &&
+        FRAME_ADJECTIVES.has(adjective) &&
+        FRAME_NOUNS.has(noun) &&
+        ["is", "are", "was"].includes(verb)
+        ? `the-${adjective}-${noun}-${verb}`
+        : undefined;
+}
+export function isAbstractAuditFrame(words) {
+    return words[0] === "the" && frameNounIndex(words) > 0
+        ? words[frameNounIndex(words)] === "audit"
+        : false;
+}
+export function matchExpandedDiscourseFrame(words) {
+    return (matchWorthAttentionFrame(words) ??
+        matchVagueFrameLocation(words) ??
+        matchEvaluativeFrame(words));
+}
+export function matchDiscourseEvaluationFrame(words) {
+    const [first] = words;
     const verbIndex = words.findIndex((word) => ABSTRACT_FRAME_VERBS.includes(word));
     const tail = words.at(-1);
     const subject = verbIndex > 0 ? words.slice(0, verbIndex) : [];
+    const workClaim = matchDiscourseWorkClaim(words, verbIndex, subject);
+    if (workClaim !== undefined) {
+        return workClaim;
+    }
+    if (words.length > 8) {
+        return undefined;
+    }
+    if (!["the", "this", "that", "it"].includes(first ?? "")) {
+        return undefined;
+    }
     return verbIndex > 0 &&
         tail !== undefined &&
         EVALUATION_TAILS.has(tail) &&