slopless 0.2.23 → 0.2.25

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

@@ -0,0 +1,214 @@
+import { FACTUAL_NEGATION_CONNECTORS, findCopularNegation, pronounCopulaStart, stripLeadingPairPivot, words } from "./negation-reframe-parts.js";
+const FRAMING_SUBJECT_NOUNS = new Set([
+    "answer",
+    "fix",
+    "goal",
+    "issue",
+    "key",
+    "point",
+    "problem",
+    "solution",
+    "strategy"
+]);
+const INSTRUCTION_ADJECTIVES = new Set([
+    "best",
+    "better",
+    "critical",
+    "essential",
+    "important",
+    "necessary",
+    "recommended",
+    "safest"
+]);
+const CONCRETE_PASSIVE_VERBS = new Set([
+    "associated",
+    "caused",
+    "classified",
+    "created",
+    "entered",
+    "linked",
+    "owned",
+    "paid",
+    "passed",
+    "produced",
+    "recorded",
+    "regulated",
+    "sent",
+    "stored",
+    "used"
+]);
+const REFERENCE_PASSIVE_VERBS = new Set(["defined", "described", "marked"]);
+const PASSIVE_EXPLANATION_LINKS = new Set([
+    "as",
+    "by",
+    "for",
+    "from",
+    "in",
+    "to",
+    "with"
+]);
+const CLAUSE_BOUNDARIES = new Set([
+    "and",
+    "but",
+    "that",
+    "when",
+    "where",
+    "which",
+    "while"
+]);
+const CONCRETE_RELATIONS = [
+    ["amount", "of"],
+    ["defined", "to", "be"],
+    ["derived", "from"],
+    ["intended", "for"],
+    ["owned", "by"],
+    ["property", "of"],
+    ["symptom", "of"],
+    ["unit", "of"]
+];
+const MAX_SHORT_SENTENCE_WORDS = 6;
+const QUANTITY_WORDS = new Set([
+    "half",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "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;
+}
+function quantityTokenCount(tokens) {
+    return (digitTokenCount(tokens) +
+        tokens.filter((token) => QUANTITY_WORDS.has(token.normalized)).length);
+}
+function acronymCount(tokens) {
+    return tokens.filter((token) => token.text.length >= 2 &&
+        token.text === token.text.toLocaleUpperCase("en") &&
+        token.text !== token.text.toLocaleLowerCase("en")).length;
+}
+function properNameCount(tokens) {
+    return tokens.filter((token, index) => {
+        const first = token.text[0];
+        return (index > 0 &&
+            first !== undefined &&
+            first >= "A" &&
+            first <= "Z" &&
+            token.text !== token.text.toLocaleUpperCase("en"));
+    }).length;
+}
+function hasReferenceEvidence(aTokens, bTokens, pairText) {
+    const digits = digitTokenCount(aTokens) + digitTokenCount(bTokens);
+    const quantities = quantityTokenCount(aTokens) + quantityTokenCount(bTokens);
+    const names = properNameCount(aTokens) + properNameCount(bTokens);
+    return (digits >= 2 ||
+        pairText.includes("/") ||
+        pairText.includes("_") ||
+        pairText.includes("@") ||
+        (acronymCount(aTokens) + acronymCount(bTokens) >= 1 && digits >= 1) ||
+        names >= 3 ||
+        (names >= 2 && quantities >= 1));
+}
+function startsWithSequence(source, sequence) {
+    return sequence.every((word, index) => source[index] === word);
+}
+function containsSequence(source, sequence) {
+    for (let index = 0; index <= source.length - sequence.length; index += 1) {
+        if (startsWithSequence(source.slice(index), sequence)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasConcreteRelation(tokenWords) {
+    return CONCRETE_RELATIONS.some((relation) => containsSequence(tokenWords, relation));
+}
+function hasInstruction(tokens) {
+    const tokenWords = words(tokens);
+    const start = pronounCopulaStart(tokens);
+    return (start !== undefined &&
+        INSTRUCTION_ADJECTIVES.has(tokenWords[start.predicateStart] ?? "") &&
+        tokenWords[start.predicateStart + 1] === "to");
+}
+function hasPassiveExplanation(bTokens) {
+    const tokenWords = words(bTokens);
+    const start = pronounCopulaStart(bTokens);
+    const isConcretePassive = (word) => CONCRETE_PASSIVE_VERBS.has(word) || REFERENCE_PASSIVE_VERBS.has(word);
+    if (start !== undefined &&
+        isConcretePassive(tokenWords[start.predicateStart] ?? "")) {
+        return true;
+    }
+    const boundary = tokenWords.findIndex((word) => CLAUSE_BOUNDARIES.has(word));
+    const firstClause = boundary < 0 ? tokenWords : tokenWords.slice(0, boundary);
+    return firstClause.some((word, index) => isConcretePassive(word) &&
+        PASSIVE_EXPLANATION_LINKS.has(firstClause[index + 1] ?? ""));
+}
+function hasPurposeOrProvenance(tokenWords) {
+    return (containsSequence(tokenWords, ["used", "to"]) ||
+        (["uses", "used"].includes(tokenWords[1] ?? "") &&
+            tokenWords.some((word, index) => ["created", "produced"].includes(word) &&
+                ["by", "from", "in"].includes(tokenWords[index + 1] ?? ""))));
+}
+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));
+    return (!aWords.includes("caused") && containsSequence(bWords, ["caused", "by"]));
+}
+function hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText) {
+    const tokenWords = words(stripLeadingPairPivot(bTokens));
+    return (hasInstruction(bTokens) ||
+        hasConcreteRelation(tokenWords) ||
+        hasPurposeOrProvenance(tokenWords) ||
+        hasDistinctCauseExplanation(aTokens, bTokens) ||
+        hasCausalPassiveExplanation(aTokens, bTokens) ||
+        hasCausalConcreteCorrection(aTokens, bTokens) ||
+        (hasReferenceEvidence(aTokens, bTokens, pairText) &&
+            hasPassiveExplanation(bTokens)));
+}
+function hasFramingNoun(tokens) {
+    const negation = findCopularNegation(tokens);
+    if (negation === undefined) {
+        return false;
+    }
+    const predicate = words(tokens).slice(negation.negatedPredicateStart, negation.negatedPredicateStart + 4);
+    return [...negation.subject, ...predicate].some((word) => FRAMING_SUBJECT_NOUNS.has(word));
+}
+function isShortReversal(aTokens, bTokens) {
+    return (aTokens.length <= MAX_SHORT_SENTENCE_WORDS &&
+        bTokens.length <= MAX_SHORT_SENTENCE_WORDS);
+}
+export function shouldReportCopularReframe(aTokens, bTokens, pairText) {
+    return (isShortReversal(aTokens, bTokens) ||
+        hasFramingNoun(aTokens) ||
+        !hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText));
+}
+//# sourceMappingURL=reframe-classification.js.map

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

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

@@ -0,0 +1,318 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+const ABSTRACT_CATEGORY_HEADS = new Set([
+    "acquisition",
+    "administration",
+    "advertising",
+    "analytics",
+    "answer",
+    "automation",
+    "awareness",
+    "brand",
+    "channel",
+    "commerce",
+    "compliance",
+    "content",
+    "control",
+    "conversion",
+    "copy",
+    "decision",
+    "delivery",
+    "demand",
+    "discoverability",
+    "discovery",
+    "distribution",
+    "documentation",
+    "editorial",
+    "enablement",
+    "engagement",
+    "execution",
+    "experience",
+    "governance",
+    "growth",
+    "hygiene",
+    "implementation",
+    "indexing",
+    "infrastructure",
+    "management",
+    "maintenance",
+    "market",
+    "marketing",
+    "media",
+    "merchandising",
+    "operations",
+    "optimization",
+    "page",
+    "plumbing",
+    "policy",
+    "positioning",
+    "procurement",
+    "product",
+    "production",
+    "publishing",
+    "ranking",
+    "recommendation",
+    "regulation",
+    "reporting",
+    "retrieval",
+    "retention",
+    "revenue",
+    "risk",
+    "sales",
+    "search",
+    "security",
+    "service",
+    "sourcing",
+    "storefront",
+    "strategy",
+    "support",
+    "trust",
+    "visibility",
+    "workflow",
+    "work"
+]);
+const ARTICLES = new Set(["a", "an", "the"]);
+const PRESENT_COPULAS = new Set(["am", "are", "is"]);
+const CONTRACTED_COPULAS = new Map([
+    ["i'm", { copula: "am", subject: ["i"] }],
+    ["you're", { copula: "are", subject: ["you"] }],
+    ["we're", { copula: "are", subject: ["we"] }],
+    ["they're", { copula: "are", subject: ["they"] }],
+    ["he's", { copula: "is", subject: ["he"] }],
+    ["she's", { copula: "is", subject: ["she"] }],
+    ["it's", { copula: "is", subject: ["it"] }],
+    ["that's", { copula: "is", subject: ["that"] }]
+]);
+const PRONOUNS = new Set([
+    "he",
+    "i",
+    "it",
+    "she",
+    "that",
+    "they",
+    "this",
+    "we",
+    "you"
+]);
+const PLURAL_PRONOUNS = new Set(["they", "we", "you"]);
+const SINGULAR_S_SUBJECTS = new Set([
+    "analytics",
+    "business",
+    "economics",
+    "logistics",
+    "news",
+    "operations",
+    "sales"
+]);
+const FACTUAL_CONNECTORS = new Set([
+    "after",
+    "although",
+    "because",
+    "before",
+    "if",
+    "since",
+    "therefore",
+    "until",
+    "when",
+    "while"
+]);
+const DETAIL_PREPOSITIONS = new Set([
+    "above",
+    "at",
+    "behind",
+    "below",
+    "beside",
+    "between",
+    "by",
+    "from",
+    "in",
+    "inside",
+    "into",
+    "near",
+    "of",
+    "on",
+    "outside",
+    "through",
+    "to",
+    "under",
+    "with",
+    "within"
+]);
+const PHYSICAL_PROPERTY_WORDS = new Set([
+    "blue",
+    "cold",
+    "dry",
+    "empty",
+    "full",
+    "green",
+    "heavy",
+    "hot",
+    "large",
+    "light",
+    "local",
+    "long",
+    "optional",
+    "red",
+    "required",
+    "shared",
+    "short",
+    "small",
+    "tall",
+    "warm",
+    "weekly",
+    "wet",
+    "wide"
+]);
+const FRAME_SUBJECTS = new Set([
+    "audit",
+    "content",
+    "data",
+    "feed",
+    "index",
+    "indexing",
+    "metadata",
+    "page",
+    "product",
+    "search",
+    "seo",
+    "visibility"
+]);
+function isCompleteSentence(text) {
+    return [".", "!", "?"].includes(text.trim().at(-1) ?? "");
+}
+function isLetter(character) {
+    return (character.toLocaleLowerCase("en") !== character.toLocaleUpperCase("en"));
+}
+function isInteriorApostrophe(text, index) {
+    return isLetter(text[index - 1] ?? "") && isLetter(text[index + 1] ?? "");
+}
+function hasQuotedValueOrNumber(text) {
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index] ?? "";
+        if ((character >= "0" && character <= "9") ||
+            ['"', "`", "\u201c", "\u201d"].includes(character)) {
+            return true;
+        }
+        if (["'", "\u2018", "\u2019"].includes(character) &&
+            !isInteriorApostrophe(text, index)) {
+            return true;
+        }
+    }
+    return false;
+}
+function withoutArticle(words) {
+    return ARTICLES.has(words[0] ?? "") ? words.slice(1) : words;
+}
+function parsePastClause(text) {
+    const words = wordTokens(text).map((token) => token.normalized);
+    const usedIndex = words.findIndex((word, index) => word === "used" && words[index + 1] === "to" && words[index + 2] === "be");
+    const subject = words.slice(0, usedIndex);
+    const label = withoutArticle(words.slice(usedIndex + 3));
+    return usedIndex > 0 &&
+        subject.length <= 4 &&
+        label.length > 0 &&
+        label.length <= 4
+        ? { label, subject }
+        : undefined;
+}
+function parsePresentClause(text) {
+    const words = wordTokens(text).map((token) => token.normalized);
+    const start = words[0] === "now" ? 1 : 0;
+    const contracted = CONTRACTED_COPULAS.get(words[start] ?? "");
+    if (contracted !== undefined) {
+        const label = withoutArticle(words.slice(start + 1));
+        return label.length > 0 && label.length <= 4
+            ? { ...contracted, label }
+            : undefined;
+    }
+    const copulaIndex = words.findIndex((word, index) => index >= start && PRESENT_COPULAS.has(word));
+    const copula = words[copulaIndex];
+    const subject = words.slice(start, copulaIndex);
+    const label = withoutArticle(words.slice(copulaIndex + 1));
+    return copulaIndex > start &&
+        copula !== undefined &&
+        subject.length <= 4 &&
+        label.length > 0 &&
+        label.length <= 4
+        ? { copula, label, subject }
+        : undefined;
+}
+function sameSubjectOrPronoun(first, second) {
+    if (first.length === second.length &&
+        first.every((word, index) => word === second[index])) {
+        return true;
+    }
+    if (second.length !== 1 || !PRONOUNS.has(second[0] ?? "")) {
+        return false;
+    }
+    const firstPronoun = first.length === 1 ? first[0] : undefined;
+    if (firstPronoun !== undefined && PRONOUNS.has(firstPronoun)) {
+        return firstPronoun === second[0];
+    }
+    const subjectHead = first.at(-1) ?? "";
+    const pluralSubject = isPluralSubjectHead(subjectHead);
+    return pluralSubject
+        ? second[0] === "they"
+        : ["it", "that", "this"].includes(second[0] ?? "");
+}
+function isPluralSubjectHead(head) {
+    return (head.endsWith("s") && !head.endsWith("ss") && !SINGULAR_S_SUBJECTS.has(head));
+}
+function hasCopulaAgreement(clause) {
+    const subject = clause.subject;
+    const copula = clause.copula;
+    if (copula === undefined) {
+        return false;
+    }
+    if (subject.length === 1 && PRONOUNS.has(subject[0] ?? "")) {
+        if (subject[0] === "i") {
+            return copula === "am";
+        }
+        return PLURAL_PRONOUNS.has(subject[0] ?? "")
+            ? copula === "are"
+            : copula === "is";
+    }
+    const head = subject.at(-1) ?? "";
+    const plural = isPluralSubjectHead(head);
+    return copula === (plural ? "are" : "is");
+}
+function isAbstractLabel(label) {
+    return ABSTRACT_CATEGORY_HEADS.has(label.at(-1) ?? "");
+}
+function hasBlockedDetail(words) {
+    return words.some((word) => FACTUAL_CONNECTORS.has(word) ||
+        DETAIL_PREPOSITIONS.has(word) ||
+        PHYSICAL_PROPERTY_WORDS.has(word));
+}
+function isPassiveLabel(label) {
+    const head = label[0] ?? "";
+    return head.endsWith("ed") || head.endsWith("en");
+}
+function isFrameSubject(subject) {
+    const head = subject.at(-1) ?? "";
+    return (FRAME_SUBJECTS.has(head) ||
+        (subject.length === 1 && ["it", "that", "this"].includes(head)));
+}
+export function matchTemporalReframe(first, second) {
+    if (!isCompleteSentence(first) ||
+        !isCompleteSentence(second) ||
+        hasQuotedValueOrNumber(first) ||
+        hasQuotedValueOrNumber(second)) {
+        return undefined;
+    }
+    const past = parsePastClause(first);
+    const present = parsePresentClause(second);
+    if (past === undefined || present === undefined) {
+        return undefined;
+    }
+    const allWords = [...past.subject, ...past.label, ...present.label];
+    return sameSubjectOrPronoun(past.subject, present.subject) &&
+        isFrameSubject(past.subject) &&
+        hasCopulaAgreement(present) &&
+        (isAbstractLabel(past.label) || isAbstractLabel(present.label)) &&
+        !hasBlockedDetail(allWords) &&
+        !isPassiveLabel(past.label) &&
+        !isPassiveLabel(present.label)
+        ? `${first} ${second}`
+        : undefined;
+}
+//# sourceMappingURL=temporal-reframe.js.map