slopless 0.2.22 → 0.2.24

package/README.md

@@ -160,10 +160,6 @@ npm audit signatures slopless
 
 This confirms the tarball you installed was built in the published source repository's Actions environment, from the commit the GitHub Release points at.
 
-## Star history
-
-[![Star History Chart](https://api.star-history.com/svg?repos=seochecks-ai/slopless&type=Date)](https://star-history.com/#seochecks-ai/slopless&Date)
-
 ## Credits
 
 [Graham Rowe](https://github.com/grahamrowe82/antislop), thanks for giving me new ideas for classes of slop to detect. Your lib is now fully incorporated with your permission.

package/dist/rules/semantic-thinness/patterns/empty-quantification.json

@@ -0,0 +1,33 @@
+{
+    "id": "empty-quantification",
+    "class": "empty-quantification",
+    "purpose": "Catch claims that minimize an unexplained act of quantification instead of naming the metric, measurement, or result.",
+    "matchMode": "suffix",
+    "maxTokens": 24,
+    "templates": ["{minimizer} put a number on {deicticObject}."],
+    "slots": {
+        "minimizer": ["just", "simply", "merely", "basically"],
+        "deicticObject": ["it", "this", "that"]
+    },
+    "rejectIf": [
+        "sentence names the metric, measured value, scale, or numbered label",
+        "sentence explains how the number was calculated or where it came from",
+        "sentence uses put literally rather than as an empty quantification claim"
+    ],
+    "positiveExamples": [
+        "The report just put a number on it.",
+        "The dashboard simply put a number on this.",
+        "The analysis merely put a number on that.",
+        "The model basically put a number on it."
+    ],
+    "negativeExamples": [
+        "The analyst labeled the third bar 42.",
+        "The meter measured the pressure at 18 PSI.",
+        "The report calculated the score from twelve survey responses.",
+        "She put the numbered label on the archive box."
+    ],
+    "notes": [
+        "The template begins at the minimizer so suffix mode permits arbitrary preceding subjects without enumerating them.",
+        "Suffix mode permits arbitrary preceding subjects but requires the vague quantification phrase to end the sentence, excluding measurements, explanations, and literal continuations."
+    ]
+}

package/dist/rules/semantic-thinness/private/pattern-data-e.js

@@ -1,5 +1,7 @@
+import emptyQuantification from "../patterns/empty-quantification.json" with { type: "json" };
 import recursiveMeaningFrame from "../patterns/recursive-meaning-frame.json" with { type: "json" };
 export const semanticThinnessPatternSetE = [
+    emptyQuantification,
     recursiveMeaningFrame
 ];
 //# sourceMappingURL=pattern-data-e.js.map

package/dist/rules/semantic-thinness/private/pattern-matcher.js

@@ -86,7 +86,12 @@ function compileSlotValues(slots) {
     return compiled;
 }
 export function compileSemanticThinnessPatterns(patterns) {
-    const matchModeFor = (pattern) => pattern.matchMode === "contains" ? "contains" : "full";
+    const matchModeFor = (pattern) => {
+        if (pattern.matchMode === "contains" || pattern.matchMode === "suffix") {
+            return pattern.matchMode;
+        }
+        return "full";
+    };
     const defaultMaxTokensFor = (pattern) => matchModeFor(pattern) === "contains"
         ? CONTAINS_MAX_TOKENS
         : FULL_MAX_TOKENS;

package/dist/rules/syntactic-patterns/closers/affirmation-closers.js

@@ -2,6 +2,10 @@ import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
 import { sectionLastSentenceUnits, sentenceUnits } from "../../../adapters/textlint/units.js";
 import { wordTokens } from "../../../shared/text/tokens.js";
 const CLOSERS = ["and that's the key.", "that's what matters."];
+const EXACT_FORMULA_LINES = new Set([
+    "that's the good stuff",
+    "that is the good stuff"
+]);
 const FORMULA_TAILS = [
     "key",
     "point",
@@ -13,9 +17,15 @@ const FORMULA_TAILS = [
 ];
 function isFormulaLine(text) {
     const lower = text.toLocaleLowerCase("en");
-    return (wordTokens(text).length <= 6 &&
-        (lower.startsWith("that's the ") || lower.startsWith("that is the ")) &&
-        FORMULA_TAILS.some((tail) => lower.includes(tail)));
+    let punctuationStart = lower.length;
+    while ([".", "!", "?"].includes(lower[punctuationStart - 1] ?? "")) {
+        punctuationStart -= 1;
+    }
+    const withoutTerminalPunctuation = lower.slice(0, punctuationStart);
+    return (EXACT_FORMULA_LINES.has(withoutTerminalPunctuation) ||
+        (wordTokens(text).length <= 6 &&
+            (lower.startsWith("that's the ") || lower.startsWith("that is the ")) &&
+            FORMULA_TAILS.some((tail) => lower.includes(tail))));
 }
 const rule = defineTextlintRule({
     detector: {

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

@@ -0,0 +1,41 @@
+import { NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+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] ?? "");
+}
+//# sourceMappingURL=copular-reframe.js.map

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 { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, 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 { hasNegativeSlopPairSignal, 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";
@@ -60,51 +60,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) {
@@ -172,43 +127,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,

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

@@ -1,5 +1,6 @@
 export const NEGATION_WORDS = new Set([
     "not",
+    "never",
     "isn't",
     "aren't",
     "wasn't",
@@ -52,18 +53,22 @@ 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 CONTRACTED_PRONOUN_COPULAS = new Map([
+    ["it's", { affirmativeAux: "is", subject: ["it"] }],
+    ["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];
@@ -121,6 +126,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);
@@ -161,6 +199,24 @@ export function findCopularNegation(tokens) {
                 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)
+            };
+        }
+        if (explicitAux !== undefined &&
+            next === "no" &&
+            (tokenWords[index + 2] === "one" || tokenWords[index + 2] === "single")) {
+            return {
+                affirmativeAux: explicitAux,
+                negatedPredicateStart: index + 1,
+                subject: tokenWords.slice(0, index)
+            };
+        }
     }
     return undefined;
 }

package/dist/rules/syntactic-patterns/contrast/private/negative-slop-frames.js

@@ -1,3 +1,7 @@
+import { hasFactualConnectorAfterNegation } from "./negation-context-gates.js";
+import { hasAbstractPolicyDirectObject } from "./policy-object.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",
@@ -27,6 +31,40 @@ const GENERIC_ACTION_VERBS = new Set([
     "walked",
     "went"
 ]);
+const NEGATED_ACTION_REFRAME_VERBS = new Set([
+    "avoid",
+    "change",
+    "create",
+    "end",
+    "erase",
+    "fix",
+    "guarantee",
+    "make",
+    "mean",
+    "remove",
+    "replace",
+    "require",
+    "skip",
+    "solve"
+]);
+const REPLACEMENT_SUBJECT_PRONOUNS = new Set(["he", "she"]);
+const PRONOUN_PAYOFF_VERBS = new Set([
+    "becomes",
+    "creates",
+    "depends",
+    "exposes",
+    "lands",
+    "means",
+    "moves",
+    "needs",
+    "points",
+    "requires",
+    "reveals",
+    "shifts",
+    "shows",
+    "turns"
+]);
+const PRONOUN_SUBJECTS = new Set(["it", "this", "that", "they", "we", "you"]);
 function startsWithPassiveCopula(tokens) {
     const tokenWords = words(tokens);
     const predicateIndex = startsWithAny(tokens, PRONOUN_REFRAME_STARTS)
@@ -81,7 +119,34 @@ function negatedActionSubject(tokens) {
     }
     return undefined;
 }
-function negativeActionReplacement(aTokens, bTokens) {
+function constrainedSetSubjectLength(tokens, subject) {
+    if (startsWithWords(tokens, subject)) {
+        return subject.length;
+    }
+    if (startsWithSubjectOrPronoun(tokens, subject)) {
+        return 1;
+    }
+    return subject.length > 1 &&
+        REPLACEMENT_SUBJECT_PRONOUNS.has(tokens[0]?.normalized ?? "")
+        ? 1
+        : undefined;
+}
+export function negatedActionReplacement(aTokens, bTokens) {
+    const tokenWords = words(aTokens);
+    const subject = negatedActionSubject(aTokens);
+    if (subject === undefined) {
+        return false;
+    }
+    const bContentTokens = stripLeadingPairPivot(bTokens);
+    const bWords = words(bContentTokens);
+    const genericVerbIndex = skipOptionalAdverbs(bWords, subject.length);
+    return (tokenWords.length <= 14 &&
+        !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
+        ((startsWithSubjectOrPronoun(bContentTokens, subject) &&
+            GENERIC_ACTION_VERBS.has(bWords[genericVerbIndex] ?? "")) ||
+            negatedActionSetReplacement(aTokens, bTokens)));
+}
+export function negatedActionSetReplacement(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     const subject = negatedActionSubject(aTokens);
     if (subject === undefined) {
@@ -89,13 +154,14 @@ function negativeActionReplacement(aTokens, bTokens) {
     }
     const bContentTokens = stripLeadingPairPivot(bTokens);
     const bWords = words(bContentTokens);
-    const verbIndex = skipOptionalAdverbs(bWords, subject.length);
-    const verb = bWords[verbIndex];
+    const subjectLength = constrainedSetSubjectLength(bContentTokens, subject);
+    const verbIndex = subjectLength === undefined
+        ? undefined
+        : skipOptionalAdverbs(bWords, subjectLength);
     return (tokenWords.length <= 14 &&
         !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
-        startsWithSubjectOrPronoun(bContentTokens, subject) &&
-        verb !== undefined &&
-        GENERIC_ACTION_VERBS.has(verb));
+        verbIndex !== undefined &&
+        hasAbstractPolicyDirectObject(bWords, verbIndex));
 }
 function notBecauseReframe(aTokens, bTokens) {
     return (startsWithWords(aTokens, ["not", "because"]) &&
@@ -130,10 +196,47 @@ export function hasNegativeSlopPairSignal(tokens) {
         hasTrailingProblemFrame(tokenWords) ||
         hasLeadingProblemFrame(tokenWords));
 }
+export function negatedActionPronounPayoff(aTokens, bTokens) {
+    const aWords = words(aTokens);
+    const bWords = words(stripLeadingPairPivot(bTokens));
+    const pronounStart = PRONOUN_SUBJECTS.has(bWords[0] ?? "") ? 1 : undefined;
+    if (pronounStart === undefined) {
+        return false;
+    }
+    const payoffVerbIndex = skipOptionalAdverbs(bWords, pronounStart);
+    if (!PRONOUN_PAYOFF_VERBS.has(bWords[payoffVerbIndex] ?? "")) {
+        return false;
+    }
+    for (let index = 0; index < aWords.length; index += 1) {
+        if (hasNegatedReframeVerb(aTokens, aWords, index)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasNegatedReframeVerb(tokens, tokenWords, index) {
+    const current = tokenWords[index];
+    const next = tokenWords[index + 1];
+    const subject = tokenWords.slice(0, index);
+    if (!validSubject(subject)) {
+        return false;
+    }
+    const negationIndex = DO_NEGATIONS.has(current ?? "")
+        ? index
+        : EXPLICIT_DO_AUXILIARIES.has(current ?? "") && next === "not"
+            ? index + 1
+            : undefined;
+    if (negationIndex === undefined ||
+        hasFactualConnectorAfterNegation(tokens, negationIndex)) {
+        return false;
+    }
+    const verbIndex = skipOptionalAdverbs(tokenWords, negationIndex + 1);
+    return NEGATED_ACTION_REFRAME_VERBS.has(tokenWords[verbIndex] ?? "");
+}
 export function negativeSlopReframe(aTokens, bTokens) {
     return (noLongerCopularReframe(aTokens, bTokens) ||
         fragmentDefinitionReframe(aTokens, bTokens) ||
-        negativeActionReplacement(aTokens, bTokens) ||
+        negatedActionReplacement(aTokens, bTokens) ||
         notBecauseReframe(aTokens, bTokens) ||
         notProblemReframe(aTokens, bTokens));
 }

package/dist/rules/syntactic-patterns/contrast/private/policy-object.js

@@ -0,0 +1,55 @@
+const ABSTRACT_POLICY_OBJECTS = new Set([
+    "condition",
+    "criterion",
+    "policy",
+    "principle",
+    "requirement",
+    "rule",
+    "standard",
+    "threshold"
+]);
+const DIRECT_OBJECT_DETERMINERS = new Set([
+    "a",
+    "an",
+    "one",
+    "that",
+    "the",
+    "this"
+]);
+const POLICY_OBJECT_MODIFIERS = new Set([
+    "access",
+    "approval",
+    "business",
+    "content",
+    "deployment",
+    "editorial",
+    "governance",
+    "launch",
+    "operating",
+    "pricing",
+    "quality",
+    "release",
+    "review",
+    "safety",
+    "security",
+    "service",
+    "spending",
+    "technical",
+    "testing",
+    "usage"
+]);
+export function hasAbstractPolicyDirectObject(tokenWords, verbIndex) {
+    if (!["set", "sets"].includes(tokenWords[verbIndex] ?? "")) {
+        return false;
+    }
+    const objectTokens = tokenWords.slice(verbIndex + 1);
+    const directObject = DIRECT_OBJECT_DETERMINERS.has(objectTokens[0] ?? "")
+        ? objectTokens.slice(1)
+        : objectTokens;
+    const [first, second] = directObject;
+    return ((directObject.length === 1 && ABSTRACT_POLICY_OBJECTS.has(first ?? "")) ||
+        (directObject.length === 2 &&
+            POLICY_OBJECT_MODIFIERS.has(first ?? "") &&
+            ABSTRACT_POLICY_OBJECTS.has(second ?? "")));
+}
+//# sourceMappingURL=policy-object.js.map