slopless 0.2.23 → 0.2.25

package/dist/rules/syntactic-patterns/contrast/private/audience-replacement.js

@@ -0,0 +1,267 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+const HUMAN_AUDIENCES = new Set([
+    "buyers",
+    "customers",
+    "people",
+    "readers",
+    "researchers",
+    "shoppers",
+    "users",
+    "visitors"
+]);
+const MACHINE_ACTORS = new Set([
+    "agent",
+    "agents",
+    "ai",
+    "algorithm",
+    "algorithms",
+    "assistant",
+    "assistants",
+    "bot",
+    "bots",
+    "crawler",
+    "crawlers",
+    "machine",
+    "machines",
+    "model",
+    "models",
+    "system",
+    "systems"
+]);
+const PREDICATES = new Map([
+    ["buy", "buy"],
+    ["buys", "buy"],
+    ["bought", "buy"],
+    ["choose", "choose"],
+    ["chooses", "choose"],
+    ["chose", "choose"],
+    ["compare", "compare"],
+    ["compares", "compare"],
+    ["compared", "compare"],
+    ["evaluate", "evaluate"],
+    ["evaluates", "evaluate"],
+    ["evaluated", "evaluate"],
+    ["find", "find"],
+    ["finds", "find"],
+    ["found", "find"],
+    ["inspect", "inspect"],
+    ["inspects", "inspect"],
+    ["inspected", "inspect"],
+    ["purchase", "purchase"],
+    ["purchases", "purchase"],
+    ["purchased", "purchase"],
+    ["read", "read"],
+    ["reads", "read"],
+    ["review", "review"],
+    ["reviews", "review"],
+    ["reviewed", "review"],
+    ["search", "search"],
+    ["searches", "search"],
+    ["searched", "search"],
+    ["select", "select"],
+    ["selects", "select"],
+    ["selected", "select"],
+    ["scan", "scan"],
+    ["scans", "scan"],
+    ["scanned", "scan"]
+]);
+const CAUSAL_CONNECTORS = new Set([
+    "after",
+    "because",
+    "if",
+    "since",
+    "therefore",
+    "until",
+    "when",
+    "while"
+]);
+const OBJECT_FILLERS = new Set([
+    "a",
+    "an",
+    "and",
+    "at",
+    "for",
+    "from",
+    "in",
+    "its",
+    "my",
+    "of",
+    "on",
+    "our",
+    "the",
+    "their",
+    "to",
+    "your"
+]);
+const OBJECT_PRONOUNS = new Set([
+    "he",
+    "her",
+    "him",
+    "it",
+    "me",
+    "she",
+    "them",
+    "they",
+    "us",
+    "we",
+    "you"
+]);
+const ARTIFACT_SURFACES = new Set([
+    "catalog",
+    "dashboard",
+    "database",
+    "feed",
+    "index",
+    "listing",
+    "page",
+    "report",
+    "site"
+]);
+function words(text) {
+    return wordTokens(text).map((token) => token.normalized);
+}
+function hasQuote(text) {
+    return [...text].some((character) => character === '"' ||
+        character === "\u201c" ||
+        character === "\u201d" ||
+        character === "`");
+}
+function hasDigit(word) {
+    return [...word].some((character) => character >= "0" && character <= "9");
+}
+function hasRejectedSurface(text, sentenceWords) {
+    return (hasQuote(text) ||
+        sentenceWords.some((word) => CAUSAL_CONNECTORS.has(word) || hasDigit(word)));
+}
+function stripTimeMarker(sentenceWords) {
+    const suffixes = [
+        ["anymore"],
+        ["now"],
+        ["any", "longer"],
+        ["these", "days"]
+    ];
+    for (const suffix of suffixes) {
+        const start = sentenceWords.length - suffix.length;
+        if (start > 0 &&
+            suffix.every((word, index) => sentenceWords[start + index] === word)) {
+            return sentenceWords.slice(0, start);
+        }
+    }
+    return undefined;
+}
+function humanAudienceEnd(sentenceWords) {
+    const first = sentenceWords[0];
+    if (first === "nobody") {
+        return 1;
+    }
+    if (first === "no" && sentenceWords[1] === "one") {
+        return 2;
+    }
+    const headIndex = first === "the" || first === "most" || first === "many" ? 1 : 0;
+    return HUMAN_AUDIENCES.has(sentenceWords[headIndex] ?? "")
+        ? headIndex + 1
+        : undefined;
+}
+function firstClaim(sentenceWords) {
+    const originalSubjectEnd = humanAudienceEnd(sentenceWords);
+    const withoutTime = stripTimeMarker(sentenceWords) ??
+        (originalSubjectEnd !== undefined &&
+            sentenceWords[originalSubjectEnd] === "no" &&
+            sentenceWords[originalSubjectEnd + 1] === "longer"
+            ? sentenceWords
+            : undefined);
+    if (withoutTime === undefined) {
+        return undefined;
+    }
+    const subjectEnd = humanAudienceEnd(withoutTime);
+    if (subjectEnd === undefined) {
+        return undefined;
+    }
+    let predicateIndex = subjectEnd;
+    const subjectStart = withoutTime[0];
+    if (subjectStart !== "nobody" && subjectStart !== "no") {
+        if (withoutTime[predicateIndex] === "don't" ||
+            withoutTime[predicateIndex] === "doesn't" ||
+            withoutTime[predicateIndex] === "didn't") {
+            predicateIndex += 1;
+        }
+        else if (withoutTime[predicateIndex] === "do" &&
+            withoutTime[predicateIndex + 1] === "not") {
+            predicateIndex += 2;
+        }
+        else if (withoutTime[predicateIndex] === "no" &&
+            withoutTime[predicateIndex + 1] === "longer") {
+            predicateIndex += 2;
+        }
+        else {
+            return undefined;
+        }
+    }
+    const predicate = PREDICATES.get(withoutTime[predicateIndex] ?? "");
+    const object = withoutTime.slice(predicateIndex + 1);
+    return predicate !== undefined && object.length > 0
+        ? { object, predicate }
+        : undefined;
+}
+function machineActorEnd(sentenceWords) {
+    let index = sentenceWords[0] === "a" ||
+        sentenceWords[0] === "an" ||
+        sentenceWords[0] === "the"
+        ? 1
+        : 0;
+    const actorStart = index;
+    while (index < actorStart + 2 &&
+        MACHINE_ACTORS.has(sentenceWords[index] ?? "")) {
+        index += 1;
+    }
+    return index > actorStart ? index : undefined;
+}
+function secondClaim(sentenceWords) {
+    const actorEnd = machineActorEnd(sentenceWords);
+    if (actorEnd === undefined) {
+        return undefined;
+    }
+    const predicate = PREDICATES.get(sentenceWords[actorEnd] ?? "");
+    const object = sentenceWords.slice(actorEnd + 1);
+    return predicate !== undefined && object.length > 0
+        ? { object, predicate }
+        : undefined;
+}
+function contentWords(object) {
+    return new Set(object.filter((word) => !OBJECT_FILLERS.has(word) && !OBJECT_PRONOUNS.has(word)));
+}
+function sharesContent(firstObject, secondObject) {
+    if (secondObject.length === 0 ||
+        secondObject.every((word) => OBJECT_PRONOUNS.has(word))) {
+        return false;
+    }
+    const firstContent = contentWords(firstObject);
+    const secondContent = contentWords(secondObject);
+    const sameContent = firstContent.size === secondContent.size &&
+        [...firstContent].every((word) => secondContent.has(word));
+    const firstCore = [...firstContent].filter((word) => !ARTIFACT_SURFACES.has(word));
+    const secondCore = [...secondContent].filter((word) => !ARTIFACT_SURFACES.has(word));
+    return (sameContent ||
+        (firstCore.length > 0 &&
+            firstCore.length === secondCore.length &&
+            firstCore.every((word) => secondCore.includes(word))));
+}
+export function matchAudienceReplacement(first, second) {
+    const firstWords = words(first);
+    const secondWords = words(second);
+    if (firstWords.length > 24 ||
+        secondWords.length > 20 ||
+        hasRejectedSurface(first, firstWords) ||
+        hasRejectedSurface(second, secondWords)) {
+        return undefined;
+    }
+    const humanClaim = firstClaim(firstWords);
+    const machineClaim = secondClaim(secondWords);
+    if (humanClaim === undefined ||
+        machineClaim?.predicate !== humanClaim.predicate ||
+        !sharesContent(humanClaim.object, machineClaim.object)) {
+        return undefined;
+    }
+    return `${first} ${second}`;
+}
+//# sourceMappingURL=audience-replacement.js.map

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

@@ -0,0 +1,79 @@
+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)) {
+        return false;
+    }
+    return startsWithSubjectCopula(bTokens, negation.subject, negation.affirmativeAux);
+}
+export function pronounCopularReframe(aTokens, bTokens) {
+    const negation = findCopularNegation(aTokens);
+    return (negation !== undefined &&
+        validSubject(negation.subject) &&
+        !startsWithNegatedPronounCopula(bTokens) &&
+        startsWithPronounCopula(bTokens));
+}
+export 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
+        ]));
+}
+export function startsWithNegatedPronounCopula(tokens) {
+    const start = pronounCopulaStart(tokens);
+    if (start === undefined) {
+        return false;
+    }
+    const tokenWords = words(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