slopless 0.2.24 → 0.2.26

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,36 +1,11 @@
 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";
-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",
-    "said",
-    "sat",
-    "shifted",
-    "stood",
-    "started",
-    "stopped",
-    "took",
-    "turned",
-    "walked",
-    "went"
-]);
+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",
@@ -48,6 +23,14 @@ const NEGATED_ACTION_REFRAME_VERBS = new Set([
     "solve"
 ]);
 const REPLACEMENT_SUBJECT_PRONOUNS = new Set(["he", "she"]);
+const EMBEDDED_CLAUSE_VERBS = new Set([
+    "believed",
+    "explained",
+    "reckoned",
+    "reported",
+    "said",
+    "thought"
+]);
 const PRONOUN_PAYOFF_VERBS = new Set([
     "becomes",
     "creates",
@@ -65,6 +48,10 @@ const PRONOUN_PAYOFF_VERBS = new Set([
     "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);
     const predicateIndex = startsWithAny(tokens, PRONOUN_REFRAME_STARTS)
@@ -74,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);
@@ -103,18 +97,31 @@ 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;
@@ -139,10 +146,14 @@ export function negatedActionReplacement(aTokens, bTokens) {
     }
     const bContentTokens = stripLeadingPairPivot(bTokens);
     const bWords = words(bContentTokens);
-    const genericVerbIndex = skipOptionalAdverbs(bWords, subject.length);
+    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) &&
+        !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)));
 }
@@ -159,7 +170,8 @@ export function negatedActionSetReplacement(aTokens, bTokens) {
         ? undefined
         : skipOptionalAdverbs(bWords, subjectLength);
     return (tokenWords.length <= 14 &&
-        !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
+        !tokenWords.some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        !bWords.some((word) => ACTION_REPLACEMENT_CONNECTORS.has(word)) &&
         verbIndex !== undefined &&
         hasAbstractPolicyDirectObject(bWords, verbIndex));
 }
@@ -221,7 +233,7 @@ function hasNegatedReframeVerb(tokens, tokenWords, index) {
     if (!validSubject(subject)) {
         return false;
     }
-    const negationIndex = DO_NEGATIONS.has(current ?? "")
+    const negationIndex = ACTION_NEGATIONS.has(current ?? "")
         ? index
         : EXPLICIT_DO_AUXILIARIES.has(current ?? "") && next === "not"
             ? index + 1
@@ -235,6 +247,7 @@ function hasNegatedReframeVerb(tokens, tokenWords, index) {
 }
 export function negativeSlopReframe(aTokens, bTokens) {
     return (noLongerCopularReframe(aTokens, bTokens) ||
+        negatedProgressiveNeverPayoff(aTokens, bTokens) ||
         fragmentDefinitionReframe(aTokens, bTokens) ||
         negatedActionReplacement(aTokens, bTokens) ||
         notBecauseReframe(aTokens, bTokens) ||

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

@@ -80,6 +80,21 @@ const QUANTITY_WORDS = new Set([
     "nine",
     "ten"
 ]);
+const TIME_DETAIL_WORDS = new Set([
+    "today",
+    "tomorrow",
+    "tonight",
+    "yesterday",
+    "noon",
+    "midnight",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday"
+]);
 function digitTokenCount(tokens) {
     return tokens.filter((token) => [...token.text].some((character) => character >= "0" && character <= "9")).length;
 }
@@ -158,6 +173,11 @@ function hasCausalPassiveExplanation(aTokens, bTokens) {
     return (words(aTokens).some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
         hasPassiveExplanation(bTokens));
 }
+function hasCausalConcreteCorrection(aTokens, bTokens) {
+    return (words(aTokens).some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        (quantityTokenCount(bTokens) > 0 ||
+            words(bTokens).some((word) => TIME_DETAIL_WORDS.has(word))));
+}
 function hasDistinctCauseExplanation(aTokens, bTokens) {
     const aWords = words(aTokens);
     const bWords = words(stripLeadingPairPivot(bTokens));
@@ -170,6 +190,7 @@ function hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText) {
         hasPurposeOrProvenance(tokenWords) ||
         hasDistinctCauseExplanation(aTokens, bTokens) ||
         hasCausalPassiveExplanation(aTokens, bTokens) ||
+        hasCausalConcreteCorrection(aTokens, bTokens) ||
         (hasReferenceEvidence(aTokens, bTokens, pairText) &&
             hasPassiveExplanation(bTokens)));
 }

package/dist/rules/syntactic-patterns/contrast/private/sequence-reframes.js

@@ -0,0 +1,9 @@
+import { matchAudienceReplacement } from "./audience-replacement.js";
+import { matchNegativeConsequence } from "./negative-consequence.js";
+import { matchTemporalReframe } from "./temporal-reframe.js";
+export function matchSequenceReframe(first, second, third) {
+    return (matchTemporalReframe(first, second) ??
+        matchAudienceReplacement(first, second) ??
+        matchNegativeConsequence(first, second, third));
+}
+//# sourceMappingURL=sequence-reframes.js.map