slopless 0.2.23 → 0.2.25

package/dist/rules/syntactic-patterns/contrast/private/inline-short-negation.js

@@ -1,6 +1,7 @@
 import { hasConcreteCorrectionEvidence } from "../../../../shared/matchers/concrete-evidence.js";
 import { hasFactualConnectorAfterNegation } from "./negation-context-gates.js";
 import { findCopularNegation, findNegationIndex, startsWithWords, words } from "./negation-reframe-parts.js";
+export { matchesInlineSemicolonReframe } from "./inline-semicolon-reframe.js";
 export function inlineNotJustCopularReframe(sentence, tokens) {
     const negation = findCopularNegation(tokens);
     const negationIndex = findNegationIndex(tokens);

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

@@ -1,9 +1,9 @@
-import { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, NEGATION_WORDS, PASSIVE_DEFINITION_VERBS, PRONOUN_REFRAME_STARTS, contrastPivotSubject, findCopularNegation, findNegationIndex, isCompleteSentence, skipOptionalAdverbs, startsWithAny, startsWithSubjectOrPronoun, startsWithSubjectVerb, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
+import { ACTION_NEGATIONS, DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, FACTUAL_NEGATION_CONNECTORS, contrastPivotSubject, findCopularNegation, findNegationIndex, isCompleteSentence, skipOptionalAdverbs, startsWithSubjectOrPronoun, startsWithSubjectVerb, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
 import { hasAbstractCommaContrast, hasAbstractNegationPayoff, hasFactualConnectorAfterNegation, hasMetaContext } from "./negation-context-gates.js";
 import { hasInlineContrastConnectorAfterNegation } from "./inline-contrast-connector.js";
 import { inlineNotBecauseReframe } from "./inline-not-because-reframe.js";
-import { inlineNotJustCopularReframe, inlineShortNegatedBeat } from "./inline-short-negation.js";
-import { hasNegativeSlopPairSignal, negativeSlopReframe } from "./negative-slop-frames.js";
+import { matchesInlineSemicolonReframe, inlineNotJustCopularReframe, inlineShortNegatedBeat } from "./inline-short-negation.js";
+import { hasNegativeSlopPairSignal, matchSequenceReframe, negatedActionPronounPayoff, negatedActionSetReplacement, negativeSlopReframe, progressiveVerbMirror, pronounCopularReframe, sameSubjectCopularReframe, shouldReportCopularReframe, startsWithNegatedPronounCopula } from "./negative-slop-frames.js";
 import { makeMeaningReframe, meaningReframe } from "./meaning-reframe.js";
 import { hasConcreteCorrectionEvidence } from "../../../../shared/matchers/concrete-evidence.js";
 import { splitSentences } from "../../../../shared/text/sentences.js";
@@ -19,8 +19,25 @@ const INLINE_NON_CONTRAST_NEGATION_FOLLOWERS = new Set([
     "only",
     "too"
 ]);
+const ACTION_PAIR_CONNECTORS = new Set([
+    ...FACTUAL_NEGATION_CONNECTORS,
+    "after"
+]);
+function inlineSemicolonEvaluativeReframe(sentence) {
+    return matchesInlineSemicolonReframe(sentence.text)
+        ? {
+            end: sentence.end,
+            start: sentence.start,
+            text: sentence.text
+        }
+        : undefined;
+}
 function inlineNegationContrast(sentence) {
     const tokens = wordTokens(sentence.text);
+    const semicolonMatch = inlineSemicolonEvaluativeReframe(sentence);
+    if (semicolonMatch !== undefined) {
+        return semicolonMatch;
+    }
     const negationIndex = findNegationIndex(tokens);
     if (negationIndex === undefined) {
         return undefined;
@@ -60,51 +77,6 @@ function inlineNegationContrast(sentence) {
         }
         : undefined;
 }
-function sameSubjectCopularReframe(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    if (negation === undefined || !validSubject(negation.subject)) {
-        return false;
-    }
-    return startsWithWords(bTokens, [
-        ...negation.subject,
-        negation.affirmativeAux
-    ]);
-}
-function pronounCopularReframe(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    return (negation !== undefined &&
-        validSubject(negation.subject) &&
-        !looksLikePassiveDefinition(aTokens, bTokens) &&
-        !startsWithNegatedPronounCopula(bTokens) &&
-        startsWithAny(bTokens, PRONOUN_REFRAME_STARTS));
-}
-function startsWithNegatedPronounCopula(tokens) {
-    for (const start of PRONOUN_REFRAME_STARTS) {
-        if (!startsWithWords(tokens, start)) {
-            continue;
-        }
-        const tokenWords = words(tokens);
-        const predicateIndex = skipOptionalAdverbs(tokenWords, start.length);
-        return NEGATION_WORDS.has(tokenWords[predicateIndex] ?? "");
-    }
-    return false;
-}
-function progressiveVerbMirror(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    if (negation === undefined || !validSubject(negation.subject)) {
-        return false;
-    }
-    const tokenWords = words(aTokens);
-    const predicateIndex = skipOptionalAdverbs(tokenWords, negation.negatedPredicateStart);
-    const verb = tokenWords[predicateIndex];
-    return (verb !== undefined &&
-        verb.endsWith("ing") &&
-        startsWithWords(bTokens, [
-            ...negation.subject,
-            negation.affirmativeAux,
-            verb
-        ]));
-}
 function needReframe(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     for (let index = 0; index < tokenWords.length; index += 1) {
@@ -135,6 +107,11 @@ function startsWithNeedAffirmative(bTokens, subject) {
 function actionVerbMirror(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     const bContentTokens = stripLeadingPairPivot(bTokens);
+    const bWords = words(bContentTokens);
+    const firstConnectors = new Set(tokenWords.filter((word) => ACTION_PAIR_CONNECTORS.has(word)));
+    if (bWords.some((word) => ACTION_PAIR_CONNECTORS.has(word) && !firstConnectors.has(word))) {
+        return false;
+    }
     for (let index = 0; index < tokenWords.length; index += 1) {
         const current = tokenWords[index];
         const next = tokenWords[index + 1];
@@ -142,7 +119,7 @@ function actionVerbMirror(aTokens, bTokens) {
         if (!validSubject(subject)) {
             continue;
         }
-        if (DO_NEGATIONS.has(current ?? "")) {
+        if (ACTION_NEGATIONS.has(current ?? "")) {
             const verbIndex = skipOptionalAdverbs(tokenWords, index + 1);
             const verb = tokenWords[verbIndex];
             if (verb !== undefined &&
@@ -172,43 +149,36 @@ function startsWithExplicitReplacement(tokens) {
 }
 function hasPairNegationSignal(tokens) {
     return (findNegationIndex(tokens) !== undefined ||
+        findCopularNegation(tokens) !== undefined ||
         contrastPivotSubject(tokens) !== undefined ||
         hasNegativeSlopPairSignal(tokens));
 }
-function looksLikePassiveDefinition(aTokens, bTokens) {
-    const aWords = words(aTokens);
-    const bWords = words(bTokens);
-    for (let index = 0; index < aWords.length - 2; index += 1) {
-        const current = aWords[index];
-        if ((current === "has" || current === "have" || current === "had") &&
-            aWords[index + 1] === "not" &&
-            aWords[index + 2] === "been" &&
-            startsWithWords(bTokens, ["it", "is"]) &&
-            PASSIVE_DEFINITION_VERBS.has(bWords[2] ?? "")) {
-            return true;
-        }
-    }
-    return false;
-}
 function sentencePairReframe(a, b) {
     const aTokens = wordTokens(a.text);
     const bTokens = wordTokens(b.text);
+    const pairText = `${a.text} ${b.text}`;
+    const hasNegatedActionSetReplacement = negatedActionSetReplacement(aTokens, bTokens);
+    const hasAllowedReplacementColon = b.text.trimEnd().endsWith(":") && hasNegatedActionSetReplacement;
     if (!isCompleteSentence(a) ||
-        !isCompleteSentence(b) ||
+        (!isCompleteSentence(b) && !hasAllowedReplacementColon) ||
         !hasPairNegationSignal(aTokens)) {
         return undefined;
     }
-    if (sameSubjectCopularReframe(aTokens, bTokens) ||
-        pronounCopularReframe(aTokens, bTokens) ||
-        progressiveVerbMirror(aTokens, bTokens) ||
+    if ((shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+        (sameSubjectCopularReframe(aTokens, bTokens) ||
+            pronounCopularReframe(aTokens, bTokens) ||
+            progressiveVerbMirror(aTokens, bTokens))) ||
         (startsWithExplicitReplacement(bTokens) &&
-            !hasConcreteCorrectionEvidence(`${a.text} ${b.text}`)) ||
+            shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+            !hasConcreteCorrectionEvidence(pairText)) ||
         meaningReframe(aTokens, bTokens) ||
         makeMeaningReframe(aTokens, bTokens) ||
         needReframe(aTokens, bTokens) ||
         actionVerbMirror(aTokens, bTokens) ||
+        negatedActionPronounPayoff(aTokens, bTokens) ||
         negativeSlopReframe(aTokens, bTokens) ||
-        explicitContrastPivotReframe(aTokens, bTokens)) {
+        (shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+            explicitContrastPivotReframe(aTokens, bTokens))) {
         return {
             end: b.end,
             start: a.start,
@@ -220,10 +190,26 @@ function sentencePairReframe(a, b) {
 export function findSentenceNegationReframes(text) {
     const sentences = splitSentences(text);
     const matches = [];
+    const matchedRanges = new Set();
+    const addMatch = (match) => {
+        const range = `${match.start}:${match.end}`;
+        if (!matchedRanges.has(range)) {
+            matchedRanges.add(range);
+            matches.push(match);
+        }
+    };
     for (const sentence of sentences) {
         const inlineMatch = inlineNegationContrast(sentence);
         if (inlineMatch !== undefined) {
-            matches.push(inlineMatch);
+            addMatch(inlineMatch);
+        }
+        const consequence = matchSequenceReframe(sentence.text, "");
+        if (consequence !== undefined) {
+            addMatch({
+                end: sentence.end,
+                start: sentence.start,
+                text: consequence
+            });
         }
     }
     for (let index = 0; index < sentences.length - 1; index += 1) {
@@ -232,11 +218,30 @@ export function findSentenceNegationReframes(text) {
         if (current === undefined || next === undefined) {
             continue;
         }
+        const third = sentences[index + 2];
+        const sequence = matchSequenceReframe(current.text, next.text, third?.text);
+        if (sequence !== undefined) {
+            const threeSentenceText = third === undefined
+                ? undefined
+                : `${current.text} ${next.text} ${third.text}`;
+            addMatch({
+                end: sequence === current.text
+                    ? current.end
+                    : sequence === threeSentenceText
+                        ? (third?.end ?? next.end)
+                        : next.end,
+                start: current.start,
+                text: sequence
+            });
+        }
         const pairMatch = sentencePairReframe(current, next);
         if (pairMatch !== undefined) {
-            matches.push(pairMatch);
+            addMatch(pairMatch);
         }
     }
-    return matches;
+    return matches.filter((match, index) => !matches.some((other, otherIndex) => otherIndex !== index &&
+        other.start <= match.start &&
+        other.end >= match.end &&
+        (other.start < match.start || other.end > match.end)));
 }
 //# sourceMappingURL=negation-reframe-matcher.js.map

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

@@ -1,20 +1,7 @@
-export const NEGATION_WORDS = new Set([
-    "not",
-    "isn't",
-    "aren't",
-    "wasn't",
-    "weren't",
-    "don't",
-    "doesn't",
-    "didn't",
-    "can't",
-    "cannot",
-    "won't",
-    "wouldn't",
-    "shouldn't",
-    "couldn't"
-]);
+import { NEGATION_WORDS } from "./negation-vocabulary.js";
+export { ACTION_NEGATIONS, DO_NEGATIONS, NEGATION_WORDS } from "./negation-vocabulary.js";
 export const COPULAR_FORMS = new Map([
+    ["am", "am"],
     ["are", "are"],
     ["aren't", "are"],
     ["is", "is"],
@@ -24,7 +11,6 @@ export const COPULAR_FORMS = new Map([
     ["were", "were"],
     ["weren't", "were"]
 ]);
-export const DO_NEGATIONS = new Set(["don't", "doesn't", "didn't"]);
 export const EXPLICIT_DO_AUXILIARIES = new Set(["do", "does", "did"]);
 export const OPTIONAL_ADVERBS = new Set([
     "actually",
@@ -38,13 +24,17 @@ export const FACTUAL_NEGATION_CONNECTORS = new Set([
     "because",
     "if",
     "since",
+    "though",
     "until",
     "when",
     "while"
 ]);
 export const PRONOUN_REFRAME_STARTS = [
+    ["i", "am"],
+    ["he", "is"],
     ["it", "is"],
     ["it", "was"],
+    ["she", "is"],
     ["this", "is"],
     ["that", "is"],
     ["they", "are"],
@@ -52,18 +42,26 @@ export const PRONOUN_REFRAME_STARTS = [
     ["you", "are"],
     ["we", "are"]
 ];
-export const PASSIVE_DEFINITION_VERBS = new Set([
-    "associated",
-    "caused",
-    "classified",
-    "defined",
-    "described",
-    "linked",
-    "marked",
-    "produced"
-]);
 const IRREGULAR_PAST_TENSE = new Map([["go", "went"]]);
 const CONTRAST_PIVOT_AFTER_NOT = new Set(["just", "merely", "only"]);
+const NEGATIVE_COPULAR_PREDICATES = new Set([
+    "never",
+    "nobody",
+    "none",
+    "nothing",
+    "nowhere"
+]);
+const NEGATIVE_NOUN_DETERMINERS = new Set(["no"]);
+const CONTRACTED_PRONOUN_COPULAS = new Map([
+    ["i'm", { affirmativeAux: "am", subject: ["i"] }],
+    ["he's", { affirmativeAux: "is", subject: ["he"] }],
+    ["it's", { affirmativeAux: "is", subject: ["it"] }],
+    ["she's", { affirmativeAux: "is", subject: ["she"] }],
+    ["that's", { affirmativeAux: "is", subject: ["that"] }],
+    ["they're", { affirmativeAux: "are", subject: ["they"] }],
+    ["we're", { affirmativeAux: "are", subject: ["we"] }],
+    ["you're", { affirmativeAux: "are", subject: ["you"] }]
+]);
 export function findNegationIndex(tokens) {
     for (let index = 0; index < tokens.length; index += 1) {
         const token = tokens[index];
@@ -88,7 +86,16 @@ function regularPastTense(verb) {
     return verb.endsWith("e") ? `${verb}d` : `${verb}ed`;
 }
 function affirmativeVerbForms(verb) {
-    return [verb, IRREGULAR_PAST_TENSE.get(verb) ?? regularPastTense(verb)];
+    const thirdPerson = verb.endsWith("y")
+        ? `${verb.slice(0, -1)}ies`
+        : ["s", "x", "z", "ch", "sh", "o"].some((ending) => verb.endsWith(ending))
+            ? `${verb}es`
+            : `${verb}s`;
+    return [
+        verb,
+        thirdPerson,
+        IRREGULAR_PAST_TENSE.get(verb) ?? regularPastTense(verb)
+    ];
 }
 export function stripLeadingPairPivot(tokens) {
     return tokens[0]?.normalized === "instead" ? tokens.slice(1) : tokens;
@@ -108,9 +115,6 @@ export function startsWithSubjectVerb(tokens, subject, verb) {
 export function words(tokens) {
     return tokens.map((token) => token.normalized);
 }
-export function hasAnyWord(tokens, candidates) {
-    return tokens.some((token) => candidates.has(token));
-}
 export function skipOptionalAdverbs(tokens, start) {
     let index = start;
     while (OPTIONAL_ADVERBS.has(tokens[index] ?? "")) {
@@ -121,6 +125,39 @@ export function skipOptionalAdverbs(tokens, start) {
 export function startsWithAny(tokens, starts) {
     return starts.some((start) => startsWithWords(tokens, start));
 }
+export function pronounCopulaStart(tokens) {
+    const firstToken = tokens[0];
+    const contracted = firstToken === undefined
+        ? undefined
+        : CONTRACTED_PRONOUN_COPULAS.get(firstToken.normalized);
+    if (contracted !== undefined) {
+        return { ...contracted, predicateStart: 1 };
+    }
+    for (const start of PRONOUN_REFRAME_STARTS) {
+        if (startsWithWords(tokens, start)) {
+            return {
+                affirmativeAux: start[1],
+                predicateStart: start.length,
+                subject: [start[0]]
+            };
+        }
+    }
+    return undefined;
+}
+export function startsWithPronounCopula(tokens) {
+    return pronounCopulaStart(tokens) !== undefined;
+}
+export function startsWithSubjectCopula(tokens, subject, affirmativeAux) {
+    if (startsWithWords(tokens, [...subject, affirmativeAux])) {
+        return true;
+    }
+    const contracted = CONTRACTED_PRONOUN_COPULAS.get(tokens[0]?.normalized ?? "");
+    if (contracted?.affirmativeAux !== affirmativeAux) {
+        return false;
+    }
+    return (subject.length === contracted.subject.length &&
+        subject.every((word, index) => word === contracted.subject[index]));
+}
 export function isCompleteSentence(sentence) {
     const trimmed = sentence.text.trim();
     const last = trimmed.at(-1);
@@ -140,6 +177,18 @@ export function hasCommaBeforeNegation(text, negationStart) {
 }
 export function findCopularNegation(tokens) {
     const tokenWords = words(tokens);
+    const contracted = CONTRACTED_PRONOUN_COPULAS.get(tokenWords[0] ?? "");
+    const contractedNegator = tokenWords[1];
+    if (contracted !== undefined &&
+        contractedNegator !== undefined &&
+        (contractedNegator === "not" ||
+            NEGATIVE_COPULAR_PREDICATES.has(contractedNegator) ||
+            NEGATIVE_NOUN_DETERMINERS.has(contractedNegator))) {
+        return {
+            ...contracted,
+            negatedPredicateStart: contractedNegator === "not" ? 2 : 1
+        };
+    }
     for (let index = 0; index < tokenWords.length; index += 1) {
         const current = tokenWords[index];
         const next = tokenWords[index + 1];
@@ -161,6 +210,25 @@ export function findCopularNegation(tokens) {
                 subject: tokenWords.slice(0, index)
             };
         }
+        if (explicitAux !== undefined &&
+            next !== undefined &&
+            NEGATIVE_NOUN_DETERMINERS.has(next) &&
+            tokenWords[index + 2] !== "longer") {
+            return {
+                affirmativeAux: explicitAux,
+                negatedPredicateStart: index + 1,
+                subject: tokenWords.slice(0, index)
+            };
+        }
+        if (explicitAux !== undefined &&
+            next !== undefined &&
+            NEGATIVE_COPULAR_PREDICATES.has(next)) {
+            return {
+                affirmativeAux: explicitAux,
+                negatedPredicateStart: index + 1,
+                subject: tokenWords.slice(0, index)
+            };
+        }
     }
     return undefined;
 }

package/dist/rules/syntactic-patterns/contrast/private/negation-vocabulary.js

@@ -0,0 +1,27 @@
+export const DO_NEGATIONS = new Set(["don't", "doesn't", "didn't"]);
+export const ACTION_NEGATIONS = new Set([
+    ...DO_NEGATIONS,
+    "can't",
+    "couldn't",
+    "hadn't",
+    "hasn't",
+    "haven't",
+    "mightn't",
+    "mustn't",
+    "needn't",
+    "shan't",
+    "shouldn't",
+    "won't",
+    "wouldn't"
+]);
+export const NEGATION_WORDS = new Set([
+    "not",
+    "never",
+    "isn't",
+    "aren't",
+    "wasn't",
+    "weren't",
+    ...ACTION_NEGATIONS,
+    "cannot"
+]);
+//# sourceMappingURL=negation-vocabulary.js.map