slopless 0.2.24 → 0.2.26

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

@@ -1,4 +1,27 @@
-import { NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+import { FACTUAL_NEGATION_CONNECTORS, NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+const AGENTIC_SYSTEM_SUBJECTS = new Set([
+    "agent",
+    "assistant",
+    "engine",
+    "model",
+    "system",
+    "tool"
+]);
+const PAYOFF_VERBS = new Set([
+    "compared",
+    "considered",
+    "encountered",
+    "entered",
+    "evaluated",
+    "found",
+    "met",
+    "qualified",
+    "ranked",
+    "reached",
+    "reviewed",
+    "selected",
+    "seen"
+]);
 export function sameSubjectCopularReframe(aTokens, bTokens) {
     const negation = findCopularNegation(aTokens);
     if (negation === undefined || !validSubject(negation.subject)) {
@@ -38,4 +61,19 @@ export function startsWithNegatedPronounCopula(tokens) {
     const predicateIndex = skipOptionalAdverbs(tokenWords, start.predicateStart);
     return NEGATION_WORDS.has(tokenWords[predicateIndex] ?? "");
 }
+export function negatedProgressiveNeverPayoff(first, second) {
+    const negation = findCopularNegation(first);
+    if (negation === undefined ||
+        !AGENTIC_SYSTEM_SUBJECTS.has(negation.subject.at(-1) ?? "") ||
+        words(first)[negation.negatedPredicateStart]?.endsWith("ing") !== true) {
+        return false;
+    }
+    const secondWords = words(second);
+    const neverIndex = secondWords.slice(1, 4).indexOf("never") + 1;
+    return (["it", "they"].includes(secondWords[0] ?? "") &&
+        neverIndex > 0 &&
+        PAYOFF_VERBS.has(secondWords[neverIndex + 1] ?? "") &&
+        !secondWords.some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        secondWords.length <= 10);
+}
 //# sourceMappingURL=copular-reframe.js.map

package/dist/rules/syntactic-patterns/contrast/private/evidence-limitation-pair.js

@@ -0,0 +1,307 @@
+import { cleanSentence, tokens } from "../../../../shared/matchers/prose-patterns.js";
+const PREFIXES = ["and ", "but ", "so "];
+const SIMPLE_SUBJECT_STARTERS = new Set([
+    "a",
+    "an",
+    "my",
+    "our",
+    "that",
+    "the",
+    "their",
+    "these",
+    "this",
+    "those",
+    "your"
+]);
+const EVIDENCE_PROXY_HEADS = new Set([
+    "award",
+    "awards",
+    "benchmark",
+    "benchmarks",
+    "case",
+    "cases",
+    "comment",
+    "comments",
+    "dashboard",
+    "dashboards",
+    "demo",
+    "demos",
+    "example",
+    "examples",
+    "metric",
+    "metrics",
+    "number",
+    "numbers",
+    "rating",
+    "ratings",
+    "review",
+    "reviews",
+    "score",
+    "scores",
+    "screenshot",
+    "screenshots",
+    "signal",
+    "signals",
+    "survey",
+    "surveys",
+    "testimonial",
+    "testimonials"
+]);
+const PLURAL_EVIDENCE_PROXY_HEADS = new Set([
+    "awards",
+    "benchmarks",
+    "cases",
+    "comments",
+    "dashboards",
+    "demos",
+    "examples",
+    "metrics",
+    "numbers",
+    "ratings",
+    "reviews",
+    "scores",
+    "screenshots",
+    "signals",
+    "surveys",
+    "testimonials"
+]);
+const COMPLEX_SUBJECT_MARKERS = new Set([
+    "about",
+    "against",
+    "among",
+    "around",
+    "as",
+    "at",
+    "beside",
+    "between",
+    "by",
+    "compared",
+    "containing",
+    "for",
+    "from",
+    "in",
+    "including",
+    "near",
+    "of",
+    "on",
+    "or",
+    "over",
+    "under",
+    "with",
+    "without",
+    "and"
+]);
+const EVIDENCE_AUXILIARIES = new Set([
+    "can",
+    "could",
+    "had",
+    "has",
+    "have",
+    "may",
+    "might",
+    "will",
+    "would"
+]);
+const EVIDENCE_ASSERTION_VERBS = new Set([
+    "confirm",
+    "confirmed",
+    "confirms",
+    "demonstrate",
+    "demonstrated",
+    "demonstrates",
+    "document",
+    "documented",
+    "documents",
+    "establish",
+    "established",
+    "establishes",
+    "imply",
+    "implied",
+    "implies",
+    "indicate",
+    "indicated",
+    "indicates",
+    "prove",
+    "proved",
+    "proven",
+    "proves",
+    "reveal",
+    "revealed",
+    "reveals",
+    "show",
+    "showed",
+    "shown",
+    "shows",
+    "signal",
+    "signaled",
+    "signalled",
+    "signals",
+    "suggest",
+    "suggested",
+    "suggests",
+    "support",
+    "supported",
+    "supports",
+    "tell",
+    "told",
+    "validate",
+    "validated",
+    "validates",
+    "verified",
+    "verifies",
+    "verify"
+]);
+const LIMITATION_REPORTING_VERBS = new Set([
+    "communicate",
+    "communicated",
+    "communicates",
+    "convey",
+    "conveyed",
+    "conveys",
+    "demonstrate",
+    "demonstrated",
+    "demonstrates",
+    "establish",
+    "established",
+    "establishes",
+    "explain",
+    "explained",
+    "explains",
+    "indicate",
+    "indicated",
+    "indicates",
+    "offer",
+    "offered",
+    "offers",
+    "provide",
+    "provided",
+    "provides",
+    "prove",
+    "proved",
+    "proves",
+    "reveal",
+    "revealed",
+    "reveals",
+    "say",
+    "said",
+    "says",
+    "show",
+    "showed",
+    "shows",
+    "signal",
+    "signaled",
+    "signalled",
+    "signals",
+    "suggest",
+    "suggested",
+    "suggests",
+    "tell",
+    "told",
+    "tells"
+]);
+const LIMITATION_AUXILIARIES = new Set(["did", "does"]);
+const CONTRACTED_LIMITATION_AUXILIARIES = new Set(["didn't", "doesn't"]);
+const REPORTING_OBJECTS = new Set(["buyers", "readers", "us", "you"]);
+const LIMITATION_PRONOUNS = new Set([
+    "it",
+    "that",
+    "these",
+    "they",
+    "this",
+    "those"
+]);
+const LOW_INFORMATION_LIMITS = [
+    ["little"],
+    ["very", "little"],
+    ["nothing"],
+    ["not", "much"],
+    ["only", "so", "much"],
+    ["something"],
+    ["no", "context"],
+    ["no", "evidence"],
+    ["no", "information"],
+    ["no", "insight"]
+];
+function evidenceSubjectHead(words) {
+    const firstWord = words[0] ?? "";
+    if (firstWord === "that" && SIMPLE_SUBJECT_STARTERS.has(words[1] ?? "")) {
+        return undefined;
+    }
+    if (!SIMPLE_SUBJECT_STARTERS.has(firstWord) &&
+        !EVIDENCE_PROXY_HEADS.has(firstWord)) {
+        return undefined;
+    }
+    const verbIndex = words.findIndex((word) => EVIDENCE_ASSERTION_VERBS.has(word));
+    const headIndex = EVIDENCE_AUXILIARIES.has(words[verbIndex - 1] ?? "")
+        ? verbIndex - 2
+        : verbIndex - 1;
+    const head = words[headIndex];
+    const subjectModifiers = words.slice(0, headIndex);
+    return verbIndex > 0 &&
+        verbIndex < words.length - 1 &&
+        head !== undefined &&
+        EVIDENCE_PROXY_HEADS.has(head) &&
+        !subjectModifiers.some((word) => COMPLEX_SUBJECT_MARKERS.has(word))
+        ? head
+        : undefined;
+}
+function startsWithLimit(words, start, limit) {
+    return limit.every((word, index) => words[start + index] === word);
+}
+function hasVagueContinuation(words, start, limit) {
+    const next = words[start + limit.length];
+    const finalWord = limit.at(-1);
+    if (["context", "evidence", "information", "insight"].includes(finalWord ?? "")) {
+        return next === undefined || next === "about" || next === "into";
+    }
+    return (!["anything", "little", "much", "nothing", "something"].includes(finalWord ?? "") ||
+        next === undefined ||
+        next === "about");
+}
+function limitationStart(words) {
+    if (LIMITATION_REPORTING_VERBS.has(words[1] ?? "")) {
+        return REPORTING_OBJECTS.has(words[2] ?? "") ? 3 : 2;
+    }
+    if (LIMITATION_AUXILIARIES.has(words[1] ?? "") &&
+        words[2] === "not" &&
+        LIMITATION_REPORTING_VERBS.has(words[3] ?? "")) {
+        return 4;
+    }
+    return CONTRACTED_LIMITATION_AUXILIARIES.has(words[1] ?? "") &&
+        LIMITATION_REPORTING_VERBS.has(words[2] ?? "")
+        ? 3
+        : -1;
+}
+function hasLowInformationLimitation(words, pluralSubject) {
+    const pronoun = words[0] ?? "";
+    const pluralPronoun = ["these", "they", "those"].includes(pronoun);
+    if (!LIMITATION_PRONOUNS.has(pronoun) || pluralPronoun !== pluralSubject) {
+        return false;
+    }
+    const start = limitationStart(words);
+    if (start >= 3 &&
+        (LIMITATION_AUXILIARIES.has(words[1] ?? "") ||
+            CONTRACTED_LIMITATION_AUXILIARIES.has(words[1] ?? ""))) {
+        return (["anything", "much"].includes(words[start] ?? "") &&
+            (words[start + 1] === undefined || words[start + 1] === "about"));
+    }
+    if (start < 0) {
+        return false;
+    }
+    return LOW_INFORMATION_LIMITS.some((limit) => {
+        if (!startsWithLimit(words, start, limit)) {
+            return false;
+        }
+        return hasVagueContinuation(words, start, limit);
+    });
+}
+export function matchEvidenceLimitationPair(first, second) {
+    const firstWords = tokens(cleanSentence(first, PREFIXES));
+    const secondWords = tokens(cleanSentence(second, PREFIXES));
+    const subjectHead = evidenceSubjectHead(firstWords);
+    return subjectHead !== undefined &&
+        hasLowInformationLimitation(secondWords, PLURAL_EVIDENCE_PROXY_HEADS.has(subjectHead))
+        ? "evidence-limitation-pair"
+        : undefined;
+}
+//# sourceMappingURL=evidence-limitation-pair.js.map

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

@@ -0,0 +1,50 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+import { findCopularNegation, pronounCopulaStart, words } from "./negation-reframe-parts.js";
+const EVALUATIVE_PREDICATES = new Set([
+    "bad",
+    "broken",
+    "empty",
+    "incomplete",
+    "messy",
+    "sloppy",
+    "untidy",
+    "useless"
+]);
+const IDENTITY_METAPHOR_HEADS = new Set([
+    "barrier",
+    "bottleneck",
+    "bridge",
+    "dead-end",
+    "door",
+    "gate",
+    "market",
+    "shelf",
+    "wall",
+    "window"
+]);
+const IDENTITY_DETERMINERS = new Set(["a", "an", "the"]);
+function startsWithIdentityMetaphor(text) {
+    const tokens = wordTokens(text);
+    const copula = pronounCopulaStart(tokens);
+    if (copula === undefined) {
+        return false;
+    }
+    const predicate = words(tokens).slice(copula.predicateStart);
+    const headIndex = IDENTITY_DETERMINERS.has(predicate[0] ?? "") ? 1 : 0;
+    return IDENTITY_METAPHOR_HEADS.has(predicate[headIndex] ?? "");
+}
+export function matchesInlineSemicolonReframe(text) {
+    const clauses = text.split(";");
+    if (clauses.length !== 2) {
+        return false;
+    }
+    const firstTokens = wordTokens(clauses[0] ?? "");
+    const negation = findCopularNegation(firstTokens);
+    if (negation === undefined) {
+        return false;
+    }
+    const predicate = words(firstTokens).slice(negation.negatedPredicateStart);
+    return (predicate.some((word) => EVALUATIVE_PREDICATES.has(word)) &&
+        startsWithIdentityMetaphor(clauses[1] ?? ""));
+}
+//# sourceMappingURL=inline-semicolon-reframe.js.map

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, contrastPivotSubject, findCopularNegation, findNegationIndex, isCompleteSentence, skipOptionalAdverbs, 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, negatedActionPronounPayoff, negatedActionSetReplacement, negativeSlopReframe, progressiveVerbMirror, pronounCopularReframe, sameSubjectCopularReframe, shouldReportCopularReframe, startsWithNegatedPronounCopula } 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;
@@ -90,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];
@@ -97,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 &&
@@ -168,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) {
@@ -180,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,21 +1,7 @@
-export const NEGATION_WORDS = new Set([
-    "not",
-    "never",
-    "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"],
@@ -25,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",
@@ -39,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"],
@@ -62,8 +51,12 @@ const NEGATIVE_COPULAR_PREDICATES = new Set([
     "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"] }],
@@ -93,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;
@@ -113,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] ?? "")) {
@@ -178,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];
@@ -201,7 +212,8 @@ export function findCopularNegation(tokens) {
         }
         if (explicitAux !== undefined &&
             next !== undefined &&
-            NEGATIVE_COPULAR_PREDICATES.has(next)) {
+            NEGATIVE_NOUN_DETERMINERS.has(next) &&
+            tokenWords[index + 2] !== "longer") {
             return {
                 affirmativeAux: explicitAux,
                 negatedPredicateStart: index + 1,
@@ -209,8 +221,8 @@ export function findCopularNegation(tokens) {
             };
         }
         if (explicitAux !== undefined &&
-            next === "no" &&
-            (tokenWords[index + 2] === "one" || tokenWords[index + 2] === "single")) {
+            next !== undefined &&
+            NEGATIVE_COPULAR_PREDICATES.has(next)) {
             return {
                 affirmativeAux: explicitAux,
                 negatedPredicateStart: index + 1,

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