slopless 0.2.23 → 0.2.25

package/dist/rules/syntactic-patterns/contrast/private/negative-consequence.js

@@ -0,0 +1,301 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+const OMISSION_VERBS = new Set(["drop", "leave", "omit", "remove", "skip"]);
+const INFORMATION_ARTIFACTS = new Set([
+    "attribute",
+    "catalog",
+    "content",
+    "description",
+    "document",
+    "evidence",
+    "feed",
+    "field",
+    "listing",
+    "metadata",
+    "page",
+    "profile",
+    "record",
+    "report"
+]);
+const CONSEQUENCE_VERBS = new Set([
+    "fail",
+    "fails",
+    "failed",
+    "lose",
+    "loses",
+    "lost",
+    "miss",
+    "misses",
+    "missed"
+]);
+const NEGATIVE_AUXILIARIES = new Set([
+    "aren't",
+    "cannot",
+    "can't",
+    "didn't",
+    "doesn't",
+    "don't",
+    "hadn't",
+    "hasn't",
+    "haven't",
+    "isn't",
+    "not",
+    "wasn't",
+    "weren't",
+    "won't",
+    "wouldn't"
+]);
+const ABSTRACT_OUTCOMES = new Set([
+    "comparison",
+    "consideration",
+    "decision",
+    "discoverability",
+    "distribution",
+    "market",
+    "ranking",
+    "recommendation",
+    "results",
+    "selection",
+    "visibility"
+]);
+const ENTRY_VERBS = new Set([
+    "appear",
+    "appears",
+    "compare",
+    "compares",
+    "enter",
+    "enters",
+    "include",
+    "includes",
+    "qualify",
+    "qualifies",
+    "rank",
+    "ranks",
+    "reach",
+    "reaches",
+    "recommend",
+    "recommends",
+    "select",
+    "selects"
+]);
+const INFORMATION_VERBS = new Set([
+    "describe",
+    "described",
+    "describes",
+    "explain",
+    "explained",
+    "explains",
+    "include",
+    "included",
+    "includes",
+    "list",
+    "listed",
+    "lists",
+    "mention",
+    "mentioned",
+    "mentions",
+    "say",
+    "said",
+    "says",
+    "show",
+    "showed",
+    "shown",
+    "shows",
+    "state",
+    "stated",
+    "states"
+]);
+const SELECTION_PREDICATES = new Map([
+    ["appeared", "appear"],
+    ["compared", "compare"],
+    ["considered", "consider"],
+    ["included", "include"],
+    ["qualified", "qualify"],
+    ["ranked", "rank"],
+    ["reached", "reach"],
+    ["recommended", "recommend"],
+    ["rejected", "reject"],
+    ["selected", "select"],
+    ["shown", "show"]
+]);
+const CAUSAL_CONNECTORS = new Set([
+    "after",
+    "because",
+    "if",
+    "since",
+    "therefore",
+    "until",
+    "when",
+    "while"
+]);
+const TECHNICAL_OR_SAFETY_WORDS = new Set([
+    "backup",
+    "bytes",
+    "checksum",
+    "citation",
+    "citations",
+    "code",
+    "database",
+    "debug",
+    "debugging",
+    "disk",
+    "error",
+    "measurement",
+    "measurements",
+    "parser",
+    "pressure",
+    "psi",
+    "records",
+    "schema",
+    "semicolon",
+    "stack",
+    "tank",
+    "trace",
+    "valve",
+    "voltage"
+]);
+function words(text) {
+    return wordTokens(text).map((token) => token.normalized);
+}
+function hasQuotedText(text) {
+    return [...text].some((character) => character === '"' ||
+        character === "\u201c" ||
+        character === "\u201d" ||
+        character === "`");
+}
+function hasDigit(word) {
+    return [...word].some((character) => character >= "0" && character <= "9");
+}
+function hasDash(text) {
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        if (character === "\u2013" || character === "\u2014") {
+            return true;
+        }
+        if (character === "-" &&
+            (text[index - 1]?.trim() === "" || text[index + 1]?.trim() === "")) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasRejectedContext(text, sentenceWords) {
+    return (hasQuotedText(text) ||
+        sentenceWords.some((word) => CAUSAL_CONNECTORS.has(word) ||
+            TECHNICAL_OR_SAFETY_WORDS.has(word) ||
+            hasDigit(word)));
+}
+function containsAny(sentenceWords, candidates) {
+    return sentenceWords.some((word) => candidates.has(word));
+}
+function omissionConsequence(first, second) {
+    const firstWords = words(first);
+    const secondWords = words(second);
+    const comma = first.indexOf(",");
+    const startsWithOmission = OMISSION_VERBS.has(firstWords[0] ?? "") &&
+        containsAny(words(first.slice(0, comma < 0 ? first.length : comma)), INFORMATION_ARTIFACTS);
+    const namesMissingInformation = firstWords.some((word, index) => word === "no" &&
+        firstWords
+            .slice(index + 1, index + 4)
+            .some((candidate) => INFORMATION_ARTIFACTS.has(candidate)));
+    if (firstWords.length > 32 ||
+        secondWords.length > 16 ||
+        (!startsWithOmission && !namesMissingInformation) ||
+        hasRejectedContext(first, firstWords) ||
+        hasRejectedContext(second, secondWords)) {
+        return false;
+    }
+    const consequenceStart = firstWords.findIndex((word, index) => index > 0 && CONSEQUENCE_VERBS.has(word));
+    const hasNegativeConsequence = consequenceStart > 0 &&
+        firstWords
+            .slice(Math.max(0, consequenceStart - 3), consequenceStart)
+            .some((word) => NEGATIVE_AUXILIARIES.has(word));
+    const neverIndex = secondWords.indexOf("never");
+    const entryVerb = neverIndex < 0
+        ? undefined
+        : secondWords.slice(neverIndex + 1).find((word) => ENTRY_VERBS.has(word));
+    const combined = [...firstWords, ...secondWords];
+    return (hasNegativeConsequence &&
+        neverIndex > 0 &&
+        entryVerb !== undefined &&
+        containsAny(combined, ABSTRACT_OUTCOMES));
+}
+function selectionOccurrences(sentenceWords) {
+    const occurrences = [];
+    sentenceWords.forEach((word, index) => {
+        const canonical = SELECTION_PREDICATES.get(word);
+        if (canonical !== undefined) {
+            occurrences.push({ canonical, index });
+        }
+    });
+    return occurrences;
+}
+function hasNegativeMarkerBefore(sentenceWords, index, marker) {
+    const previous = sentenceWords[index - 1];
+    if (previous === marker) {
+        return true;
+    }
+    const clauseStart = sentenceWords.lastIndexOf(marker, index - 1);
+    return clauseStart >= 0 && index - clauseStart <= 3;
+}
+function inlineSelectionClaim(text, allowStackedNever) {
+    const sentenceWords = words(text);
+    if (sentenceWords.length > 14 || hasRejectedContext(text, sentenceWords)) {
+        return false;
+    }
+    const occurrences = selectionOccurrences(sentenceWords);
+    if (occurrences.length < 2) {
+        return false;
+    }
+    const repeatedAcrossNegation = occurrences.some((firstOccurrence, index) => occurrences
+        .slice(index + 1)
+        .some((secondOccurrence) => firstOccurrence.canonical === secondOccurrence.canonical &&
+        hasNegativeMarkerBefore(sentenceWords, firstOccurrence.index, "not") &&
+        hasNegativeMarkerBefore(sentenceWords, secondOccurrence.index, "never")));
+    const stackedNeverPredicates = occurrences.filter((occurrence) => hasNegativeMarkerBefore(sentenceWords, occurrence.index, "never")).length >= 2;
+    return ((hasDash(text) && repeatedAcrossNegation) ||
+        (allowStackedNever && stackedNeverPredicates));
+}
+function artifactInformationClaim(text) {
+    const sentenceWords = words(text);
+    if (sentenceWords.length > 18 || hasRejectedContext(text, sentenceWords)) {
+        return false;
+    }
+    const neverIndex = sentenceWords.indexOf("never");
+    if (neverIndex < 1 || neverIndex > 5) {
+        return false;
+    }
+    const subject = sentenceWords.slice(0, neverIndex);
+    return (containsAny(subject, INFORMATION_ARTIFACTS) &&
+        INFORMATION_VERBS.has(sentenceWords[neverIndex + 1] ?? "") &&
+        sentenceWords.length > neverIndex + 2);
+}
+function shortOutcomeFragment(text) {
+    const sentenceWords = words(text);
+    return (sentenceWords.length > 0 &&
+        sentenceWords.length <= 3 &&
+        !hasRejectedContext(text, sentenceWords) &&
+        !sentenceWords.includes("never"));
+}
+function artifactSelectionSequence(first, second, third) {
+    if (!artifactInformationClaim(first)) {
+        return undefined;
+    }
+    if (inlineSelectionClaim(second, true)) {
+        return `${first} ${second}`;
+    }
+    return third !== undefined &&
+        shortOutcomeFragment(second) &&
+        inlineSelectionClaim(third, true)
+        ? `${first} ${second} ${third}`
+        : undefined;
+}
+export function matchNegativeConsequence(first, second, third) {
+    if (second.length === 0) {
+        return inlineSelectionClaim(first, false) ? first : undefined;
+    }
+    if (omissionConsequence(first, second)) {
+        return `${first} ${second}`;
+    }
+    return artifactSelectionSequence(first, second, third);
+}
+//# sourceMappingURL=negative-consequence.js.map

package/dist/rules/syntactic-patterns/contrast/private/negative-slop-frames.js

@@ -1,31 +1,56 @@
-import { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, FACTUAL_NEGATION_CONNECTORS, PRONOUN_REFRAME_STARTS, hasAnyWord, skipOptionalAdverbs, startsWithAny, startsWithSubjectOrPronoun, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
-const GENERIC_ACTION_VERBS = new Set([
-    "asked",
-    "built",
-    "called",
-    "crossed",
-    "found",
-    "gave",
-    "left",
-    "looked",
-    "made",
-    "moved",
-    "opened",
-    "pointed",
-    "raised",
-    "reached",
-    "pulled",
-    "kept",
+import { hasFactualConnectorAfterNegation } from "./negation-context-gates.js";
+import { hasAbstractPolicyDirectObject } from "./policy-object.js";
+import { negatedProgressiveNeverPayoff } from "./copular-reframe.js";
+import { GENERIC_ACTION_VERBS } from "./action-reframe-vocabulary.js";
+export { shouldReportCopularReframe } from "./reframe-classification.js";
+export { progressiveVerbMirror, pronounCopularReframe, sameSubjectCopularReframe, startsWithNegatedPronounCopula } from "./copular-reframe.js";
+export { matchSequenceReframe } from "./sequence-reframes.js";
+import { ACTION_NEGATIONS, EXPLICIT_DO_AUXILIARIES, FACTUAL_NEGATION_CONNECTORS, PRONOUN_REFRAME_STARTS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithAny, startsWithSubjectOrPronoun, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
+const NEGATED_ACTION_REFRAME_VERBS = new Set([
+    "avoid",
+    "change",
+    "create",
+    "end",
+    "erase",
+    "fix",
+    "guarantee",
+    "make",
+    "mean",
+    "remove",
+    "replace",
+    "require",
+    "skip",
+    "solve"
+]);
+const REPLACEMENT_SUBJECT_PRONOUNS = new Set(["he", "she"]);
+const EMBEDDED_CLAUSE_VERBS = new Set([
+    "believed",
+    "explained",
+    "reckoned",
+    "reported",
     "said",
-    "sat",
-    "shifted",
-    "stood",
-    "started",
-    "stopped",
-    "took",
-    "turned",
-    "walked",
-    "went"
+    "thought"
+]);
+const PRONOUN_PAYOFF_VERBS = new Set([
+    "becomes",
+    "creates",
+    "depends",
+    "exposes",
+    "lands",
+    "means",
+    "moves",
+    "needs",
+    "points",
+    "requires",
+    "reveals",
+    "shifts",
+    "shows",
+    "turns"
+]);
+const PRONOUN_SUBJECTS = new Set(["it", "this", "that", "they", "we", "you"]);
+const ACTION_REPLACEMENT_CONNECTORS = new Set([
+    ...FACTUAL_NEGATION_CONNECTORS,
+    "after"
 ]);
 function startsWithPassiveCopula(tokens) {
     const tokenWords = words(tokens);
@@ -36,6 +61,13 @@ function startsWithPassiveCopula(tokens) {
 }
 function noLongerCopularReframe(aTokens, bTokens) {
     const tokenWords = words(aTokens);
+    const contractedStart = pronounCopulaStart(aTokens);
+    if (contractedStart !== undefined &&
+        tokenWords[contractedStart.predicateStart] === "no" &&
+        tokenWords[contractedStart.predicateStart + 1] === "longer") {
+        return (startsWithSubjectOrPronoun(bTokens, contractedStart.subject) &&
+            !startsWithPassiveCopula(bTokens));
+    }
     for (let index = 0; index < tokenWords.length - 2; index += 1) {
         const current = tokenWords[index];
         const subject = tokenWords.slice(0, index);
@@ -65,23 +97,48 @@ function fragmentDefinitionReframe(aTokens, bTokens) {
 }
 function negatedActionSubject(tokens) {
     const tokenWords = words(tokens);
+    const copularNegation = findCopularNegation(tokens);
+    if (copularNegation !== undefined &&
+        validSubject(copularNegation.subject) &&
+        tokenWords[copularNegation.negatedPredicateStart]?.endsWith("ing") === true) {
+        return copularNegation.subject;
+    }
     for (let index = 0; index < tokenWords.length; index += 1) {
         const current = tokenWords[index];
         const next = tokenWords[index + 1];
         const subject = tokenWords.slice(0, index);
-        if (!validSubject(subject)) {
+        if (!validSubject(subject) ||
+            subject.some((word) => EMBEDDED_CLAUSE_VERBS.has(word))) {
             continue;
         }
-        if (DO_NEGATIONS.has(current ?? "")) {
-            return subject;
+        if (ACTION_NEGATIONS.has(current ?? "")) {
+            return tokenWords[index + 1] !== undefined &&
+                !tokenWords.slice(index + 1).includes("and")
+                ? subject
+                : undefined;
         }
         if (EXPLICIT_DO_AUXILIARIES.has(current ?? "") && next === "not") {
-            return subject;
+            return tokenWords[index + 2] !== undefined &&
+                !tokenWords.slice(index + 2).includes("and")
+                ? subject
+                : undefined;
         }
     }
     return undefined;
 }
-function negativeActionReplacement(aTokens, bTokens) {
+function constrainedSetSubjectLength(tokens, subject) {
+    if (startsWithWords(tokens, subject)) {
+        return subject.length;
+    }
+    if (startsWithSubjectOrPronoun(tokens, subject)) {
+        return 1;
+    }
+    return subject.length > 1 &&
+        REPLACEMENT_SUBJECT_PRONOUNS.has(tokens[0]?.normalized ?? "")
+        ? 1
+        : undefined;
+}
+export function negatedActionReplacement(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     const subject = negatedActionSubject(aTokens);
     if (subject === undefined) {
@@ -89,13 +146,34 @@ function negativeActionReplacement(aTokens, bTokens) {
     }
     const bContentTokens = stripLeadingPairPivot(bTokens);
     const bWords = words(bContentTokens);
-    const verbIndex = skipOptionalAdverbs(bWords, subject.length);
-    const verb = bWords[verbIndex];
+    const subjectLength = constrainedSetSubjectLength(bContentTokens, subject);
+    const genericVerbIndex = subjectLength === undefined
+        ? undefined
+        : skipOptionalAdverbs(bWords, subjectLength);
     return (tokenWords.length <= 14 &&
-        !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
-        startsWithSubjectOrPronoun(bContentTokens, subject) &&
-        verb !== undefined &&
-        GENERIC_ACTION_VERBS.has(verb));
+        !tokenWords.some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        !bWords.some((word) => ACTION_REPLACEMENT_CONNECTORS.has(word)) &&
+        ((genericVerbIndex !== undefined &&
+            GENERIC_ACTION_VERBS.has(bWords[genericVerbIndex] ?? "")) ||
+            negatedActionSetReplacement(aTokens, bTokens)));
+}
+export function negatedActionSetReplacement(aTokens, bTokens) {
+    const tokenWords = words(aTokens);
+    const subject = negatedActionSubject(aTokens);
+    if (subject === undefined) {
+        return false;
+    }
+    const bContentTokens = stripLeadingPairPivot(bTokens);
+    const bWords = words(bContentTokens);
+    const subjectLength = constrainedSetSubjectLength(bContentTokens, subject);
+    const verbIndex = subjectLength === undefined
+        ? undefined
+        : skipOptionalAdverbs(bWords, subjectLength);
+    return (tokenWords.length <= 14 &&
+        !tokenWords.some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        !bWords.some((word) => ACTION_REPLACEMENT_CONNECTORS.has(word)) &&
+        verbIndex !== undefined &&
+        hasAbstractPolicyDirectObject(bWords, verbIndex));
 }
 function notBecauseReframe(aTokens, bTokens) {
     return (startsWithWords(aTokens, ["not", "because"]) &&
@@ -130,10 +208,48 @@ export function hasNegativeSlopPairSignal(tokens) {
         hasTrailingProblemFrame(tokenWords) ||
         hasLeadingProblemFrame(tokenWords));
 }
+export function negatedActionPronounPayoff(aTokens, bTokens) {
+    const aWords = words(aTokens);
+    const bWords = words(stripLeadingPairPivot(bTokens));
+    const pronounStart = PRONOUN_SUBJECTS.has(bWords[0] ?? "") ? 1 : undefined;
+    if (pronounStart === undefined) {
+        return false;
+    }
+    const payoffVerbIndex = skipOptionalAdverbs(bWords, pronounStart);
+    if (!PRONOUN_PAYOFF_VERBS.has(bWords[payoffVerbIndex] ?? "")) {
+        return false;
+    }
+    for (let index = 0; index < aWords.length; index += 1) {
+        if (hasNegatedReframeVerb(aTokens, aWords, index)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasNegatedReframeVerb(tokens, tokenWords, index) {
+    const current = tokenWords[index];
+    const next = tokenWords[index + 1];
+    const subject = tokenWords.slice(0, index);
+    if (!validSubject(subject)) {
+        return false;
+    }
+    const negationIndex = ACTION_NEGATIONS.has(current ?? "")
+        ? index
+        : EXPLICIT_DO_AUXILIARIES.has(current ?? "") && next === "not"
+            ? index + 1
+            : undefined;
+    if (negationIndex === undefined ||
+        hasFactualConnectorAfterNegation(tokens, negationIndex)) {
+        return false;
+    }
+    const verbIndex = skipOptionalAdverbs(tokenWords, negationIndex + 1);
+    return NEGATED_ACTION_REFRAME_VERBS.has(tokenWords[verbIndex] ?? "");
+}
 export function negativeSlopReframe(aTokens, bTokens) {
     return (noLongerCopularReframe(aTokens, bTokens) ||
+        negatedProgressiveNeverPayoff(aTokens, bTokens) ||
         fragmentDefinitionReframe(aTokens, bTokens) ||
-        negativeActionReplacement(aTokens, bTokens) ||
+        negatedActionReplacement(aTokens, bTokens) ||
         notBecauseReframe(aTokens, bTokens) ||
         notProblemReframe(aTokens, bTokens));
 }

package/dist/rules/syntactic-patterns/contrast/private/policy-object.js

@@ -0,0 +1,55 @@
+const ABSTRACT_POLICY_OBJECTS = new Set([
+    "condition",
+    "criterion",
+    "policy",
+    "principle",
+    "requirement",
+    "rule",
+    "standard",
+    "threshold"
+]);
+const DIRECT_OBJECT_DETERMINERS = new Set([
+    "a",
+    "an",
+    "one",
+    "that",
+    "the",
+    "this"
+]);
+const POLICY_OBJECT_MODIFIERS = new Set([
+    "access",
+    "approval",
+    "business",
+    "content",
+    "deployment",
+    "editorial",
+    "governance",
+    "launch",
+    "operating",
+    "pricing",
+    "quality",
+    "release",
+    "review",
+    "safety",
+    "security",
+    "service",
+    "spending",
+    "technical",
+    "testing",
+    "usage"
+]);
+export function hasAbstractPolicyDirectObject(tokenWords, verbIndex) {
+    if (!["set", "sets"].includes(tokenWords[verbIndex] ?? "")) {
+        return false;
+    }
+    const objectTokens = tokenWords.slice(verbIndex + 1);
+    const directObject = DIRECT_OBJECT_DETERMINERS.has(objectTokens[0] ?? "")
+        ? objectTokens.slice(1)
+        : objectTokens;
+    const [first, second] = directObject;
+    return ((directObject.length === 1 && ABSTRACT_POLICY_OBJECTS.has(first ?? "")) ||
+        (directObject.length === 2 &&
+            POLICY_OBJECT_MODIFIERS.has(first ?? "") &&
+            ABSTRACT_POLICY_OBJECTS.has(second ?? "")));
+}
+//# sourceMappingURL=policy-object.js.map