@faircopy/rules-nlp 1.15.0 → 1.17.0

package/dist/index.js

@@ -1,3 +1,171 @@
+// src/no-absolute-intensifiers.ts
+var DEFAULT_INTENSIFIERS = [
+  "very",
+  "really",
+  "completely",
+  "totally",
+  "absolutely",
+  "utterly",
+  "quite",
+  "extremely",
+  "perfectly",
+  "entirely"
+];
+var DEFAULT_ABSOLUTES = [
+  "unique",
+  "finished",
+  "destroyed",
+  "essential",
+  "perfect",
+  "impossible",
+  "dead",
+  "empty",
+  "full",
+  "silent",
+  "unanimous",
+  "infinite",
+  "eternal",
+  "flawless",
+  "ultimate",
+  "final",
+  "complete",
+  "total",
+  "absolute"
+];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function longestFirst(values) {
+  return [...values].sort((left, right) => right.length - left.length);
+}
+function buildPattern(intensifiers, absolutes) {
+  const intensifierPattern = longestFirst(intensifiers).map((phrase) => escapeRegExp(phrase).replace(/\\s+/g, "\\s+")).join("|");
+  const absolutePattern = longestFirst(absolutes).map((phrase) => escapeRegExp(phrase).replace(/\\s+/g, "\\s+")).join("|");
+  return new RegExp(
+    `\\b(${intensifierPattern})\\s+\\b(${absolutePattern})(?![\\w'-])`,
+    "gi"
+  );
+}
+var noAbsoluteIntensifiers = {
+  id: "no-absolute-intensifiers",
+  description: "Flag intensifiers before absolute adjectives",
+  defaults: {
+    intensifiers: DEFAULT_INTENSIFIERS,
+    absolutes: DEFAULT_ABSOLUTES
+  },
+  help: 'Absolute adjectives already express an extreme. Intensifiers like "very" before them are redundant and weaken the claim. Remove the intensifier or replace the phrase with concrete evidence.',
+  check({ text, sourceMap, options }) {
+    const diagnostics = [];
+    const intensifiers = options.intensifiers?.length ? options.intensifiers : DEFAULT_INTENSIFIERS;
+    const absolutes = options.absolutes?.length ? options.absolutes : DEFAULT_ABSOLUTES;
+    if (!intensifiers.length || !absolutes.length) return diagnostics;
+    const re = buildPattern(intensifiers, absolutes);
+    let match;
+    while ((match = re.exec(text)) !== null) {
+      const matchedText = match[0];
+      const intensifier = match[1];
+      const absolute = match[2];
+      const matchStart = match.index;
+      const matchEnd = matchStart + matchedText.length;
+      const start = sourceMap[matchStart];
+      const end = sourceMap[matchEnd - 1];
+      if (start === void 0 || end === void 0) continue;
+      const suggest = {
+        description: `remove "${intensifier}" before "${absolute}"`,
+        edits: [{ range: { start, end: end + 1 }, replacement: absolute }]
+      };
+      diagnostics.push({
+        ruleId: "no-absolute-intensifiers",
+        severity: "warn",
+        message: `"${matchedText}" is redundant \u2014 "${absolute}" is already absolute`,
+        range: { start, end: end + 1 },
+        help: noAbsoluteIntensifiers.help,
+        suggest
+      });
+    }
+    return diagnostics.sort((left, right) => left.range.start - right.range.start);
+  }
+};
+
+// src/utils.ts
+import nlp from "compromise";
+function createDoc(text) {
+  return nlp(text);
+}
+function getMatchOccurrences(text, matches) {
+  const json = matches.json({ offset: true, text: true, terms: { offset: true } });
+  return json.flatMap((entry) => {
+    const start = entry.offset?.start ?? entry.terms?.[0]?.offset?.start;
+    const length = entry.offset?.length ?? sumTermLengths(entry.terms);
+    if (typeof start !== "number" || typeof length !== "number" || length <= 0) {
+      return [];
+    }
+    return [{
+      text: entry.text ?? text.slice(start, start + length),
+      start,
+      end: start + length
+    }];
+  });
+}
+function getOccurrenceRange(sourceMap, occurrence) {
+  const start = sourceMap[occurrence.start];
+  const end = sourceMap[occurrence.end - 1];
+  if (start === void 0 || end === void 0) return null;
+  return { start, end: end + 1 };
+}
+function sumTermLengths(terms) {
+  if (!terms?.length) return void 0;
+  let total = 0;
+  for (const term of terms) {
+    const length = term.offset?.length;
+    if (typeof length !== "number") return void 0;
+    total += length;
+  }
+  return total;
+}
+
+// src/no-adverb-overuse.ts
+var DEFAULT_MAX_ADVERBS = 2;
+var DEFAULT_ALLOWED_ADVERBS = ["only"];
+var noAdverbOveruse = {
+  id: "no-adverb-overuse",
+  description: "Flag sentences with more than two -ly adverbs",
+  defaults: { maxAdverbs: DEFAULT_MAX_ADVERBS, allowedAdverbs: DEFAULT_ALLOWED_ADVERBS },
+  help: "Too many -ly adverbs in one sentence make copy feel padded. Remove the adverb, replace it with a stronger verb or adjective, or add it to allowedAdverbs if it is essential.",
+  check({ text, sourceMap, options }) {
+    const maxAdverbs = options.maxAdverbs ?? DEFAULT_MAX_ADVERBS;
+    const allowed = new Set((options.allowedAdverbs ?? DEFAULT_ALLOWED_ADVERBS).map((value) => value.toLowerCase()));
+    const doc = createDoc(text);
+    const sentences = doc.sentences().json({ offset: true, terms: { offset: true, tags: true } });
+    const diagnostics = [];
+    for (const sentence of sentences) {
+      if (!sentence.terms) continue;
+      const occurrences = sentence.terms.filter((term) => term.tags?.includes("Adverb")).map((term) => {
+        const start = term.offset?.start;
+        const length = term.offset?.length;
+        return {
+          text: term.text?.replace(/[^a-zA-Z]+$/, "") ?? "",
+          start: typeof start === "number" ? start : 0,
+          end: typeof start === "number" && typeof length === "number" ? start + length : 0
+        };
+      }).filter((occurrence) => /ly$/i.test(occurrence.text)).filter((occurrence) => !allowed.has(occurrence.text.toLowerCase())).sort((left, right) => left.start - right.start);
+      for (let index = maxAdverbs; index < occurrences.length; index += 1) {
+        const occurrence = occurrences[index];
+        const range = getOccurrenceRange(sourceMap, occurrence);
+        if (!range) continue;
+        diagnostics.push({
+          ruleId: "no-adverb-overuse",
+          severity: "warn",
+          message: `reduce adverb overuse: "${occurrence.text}" exceeds the limit of ${maxAdverbs} -ly adverb${maxAdverbs === 1 ? "" : "s"} per sentence`,
+          range,
+          help: noAdverbOveruse.help
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+
 // src/no-buzzword-stacks.ts
 var DEFAULT_TERMS = [
   "alignment",
@@ -77,41 +245,74 @@ function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/utils.ts
-import nlp from "compromise";
-function createDoc(text) {
-  return nlp(text);
-}
-function getMatchOccurrences(text, matches) {
-  const json = matches.json({ offset: true, text: true, terms: { offset: true } });
-  return json.flatMap((entry) => {
-    const start = entry.offset?.start ?? entry.terms?.[0]?.offset?.start;
-    const length = entry.offset?.length ?? sumTermLengths(entry.terms);
-    if (typeof start !== "number" || typeof length !== "number" || length <= 0) {
+// src/no-complex-readability.ts
+var DEFAULT_OPTIONS = {
+  maxGradeLevel: 12,
+  minSentences: 3,
+  minWords: 30
+};
+var noComplexReadability = {
+  id: "no-complex-readability",
+  description: "Flag prose whose Flesch-Kincaid grade level exceeds a target",
+  defaults: { ...DEFAULT_OPTIONS },
+  help: "Landing-page copy should be readable by a broad audience. Break long sentences, replace jargon, and front-load the point until the grade level drops.",
+  check({ text, sourceMap, options }) {
+    const maxGradeLevel = options.maxGradeLevel ?? DEFAULT_OPTIONS.maxGradeLevel;
+    const minSentences = options.minSentences ?? DEFAULT_OPTIONS.minSentences;
+    const minWords = options.minWords ?? DEFAULT_OPTIONS.minWords;
+    const sentences = getSentences(text);
+    const words = getWords(text);
+    if (sentences.length < minSentences || words.length < minWords) {
       return [];
     }
+    const syllables = words.reduce((sum, word) => sum + countSyllables(word), 0);
+    const grade = fleschKincaidGrade(words.length, sentences.length, syllables);
+    if (grade <= maxGradeLevel) {
+      return [];
+    }
+    const start = sourceMap[0];
+    const end = sourceMap[sourceMap.length - 1];
+    if (start === void 0 || end === void 0) return [];
     return [{
-      text: entry.text ?? text.slice(start, start + length),
-      start,
-      end: start + length
+      ruleId: "no-complex-readability",
+      severity: "warn",
+      message: `readability is grade ${grade.toFixed(1)} \u2014 simplify to ${maxGradeLevel} or below`,
+      range: { start, end: end + 1 },
+      help: noComplexReadability.help
     }];
-  });
+  }
+};
+function getSentences(text) {
+  const parts = text.split(/([.!?]+)/);
+  const sentences = [];
+  for (let i = 0; i < parts.length; i += 2) {
+    const sentence = parts[i];
+    const terminator = parts[i + 1] ?? "";
+    const combined = (sentence ?? "") + terminator;
+    const trimmed = combined.trim();
+    if (trimmed) sentences.push(trimmed);
+  }
+  return sentences;
 }
-function getOccurrenceRange(sourceMap, occurrence) {
-  const start = sourceMap[occurrence.start];
-  const end = sourceMap[occurrence.end - 1];
-  if (start === void 0 || end === void 0) return null;
-  return { start, end: end + 1 };
+function getWords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s'-]/g, " ").split(/\s+/).filter((word) => word.length > 0 && /[a-z0-9]/.test(word));
 }
-function sumTermLengths(terms) {
-  if (!terms?.length) return void 0;
-  let total = 0;
-  for (const term of terms) {
-    const length = term.offset?.length;
-    if (typeof length !== "number") return void 0;
-    total += length;
+function countSyllables(word) {
+  const cleaned = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!cleaned) return 0;
+  if (cleaned.length <= 3) return 1;
+  const vowels = cleaned.match(/[aeiouy]+/g);
+  if (!vowels) return 1;
+  let count = vowels.length;
+  if (cleaned.endsWith("e")) count--;
+  if (cleaned.endsWith("le") && cleaned.length > 2 && !/[aeiouy]$/.test(cleaned[cleaned.length - 3] ?? "")) {
+    count++;
   }
-  return total;
+  return Math.max(1, count);
+}
+function fleschKincaidGrade(words, sentences, syllables) {
+  if (sentences === 0 || words === 0) return 0;
+  return 0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59;
 }
 
 // src/no-expletive-openers.ts
@@ -255,7 +456,7 @@ var noFuturePromises = {
     const diagnostics = [];
     const phrases = options.phrases?.length ? options.phrases : DEFAULT_PHRASES3;
     for (const phrase of phrases) {
-      const re = new RegExp(`\\b${escapeRegExp(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp2(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const matchedPhrase = match[0];
@@ -274,7 +475,7 @@ var noFuturePromises = {
     return diagnostics.sort((left, right) => left.range.start - right.range.start);
   }
 };
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -300,7 +501,7 @@ var noHedgeWords = {
     const diagnostics = [];
     const hedges = options.hedges?.length ? options.hedges : DEFAULT_HEDGES;
     for (const hedge of hedges) {
-      const re = new RegExp(`\\b${escapeRegExp2(hedge).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp3(hedge).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const phrase = match[0];
@@ -319,7 +520,7 @@ var noHedgeWords = {
     return diagnostics;
   }
 };
-function escapeRegExp2(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -344,7 +545,7 @@ var noJargon = {
     const diagnostics = [];
     const phrases = options.phrases?.length ? options.phrases : DEFAULT_PHRASES4;
     for (const phrase of phrases) {
-      const re = new RegExp(`\\b${escapeRegExp3(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp4(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const matchedPhrase = match[0];
@@ -363,7 +564,7 @@ var noJargon = {
     return diagnostics.sort((left, right) => left.range.start - right.range.start);
   }
 };
-function escapeRegExp3(value) {
+function escapeRegExp4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -389,7 +590,7 @@ var noMeaninglessModifiers = {
     const diagnostics = [];
     const modifiers = options.modifiers?.length ? options.modifiers : DEFAULT_MODIFIERS;
     for (const modifier of modifiers) {
-      const re = new RegExp(`\\b${escapeRegExp4(modifier).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp5(modifier).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const matchedModifier = match[0];
@@ -408,10 +609,91 @@ var noMeaninglessModifiers = {
     return diagnostics.sort((left, right) => left.range.start - right.range.start);
   }
 };
-function escapeRegExp4(value) {
+function escapeRegExp5(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/no-non-inclusive-language.ts
+var DEFAULT_TERMS2 = [
+  { term: "guys", alternatives: ["everyone", "team", "folks"] },
+  { term: "manpower", alternatives: ["workforce", "staffing", "personnel"] },
+  { term: "whitelist", alternatives: ["allowlist"] },
+  { term: "blacklist", alternatives: ["denylist", "blocklist"] },
+  { term: "master", alternatives: ["primary", "main", "leader"] },
+  { term: "slave", alternatives: ["secondary", "replica", "follower"] },
+  { term: "crazy", alternatives: ["unexpected", "intense", "extreme"] },
+  { term: "insane", alternatives: ["extreme", "unbelievable", "remarkable"] },
+  { term: "dumb", alternatives: ["unhelpful", "poor", "uninformed"] },
+  { term: "lame", alternatives: ["unimpressive", "inadequate", "weak"] },
+  { term: "sanity check", alternatives: ["quick check", "confidence check", "verification"], exact: true },
+  { term: "blind spot", alternatives: ["unaware area", "gap", "oversight"], exact: true },
+  { term: "grandfathered", alternatives: ["legacy status", "exempted"] },
+  { term: "mankind", alternatives: ["humanity", "humankind", "people"] }
+];
+var VERB_AMBIGUOUS_TERMS = /* @__PURE__ */ new Set(["master", "slave"]);
+function toMatchPattern(rawTerm) {
+  return rawTerm;
+}
+function isProblematicUsage(term, terms) {
+  if (!VERB_AMBIGUOUS_TERMS.has(term.term.toLowerCase())) return true;
+  if (terms.length !== 1) return true;
+  const tags = terms[0].tags ?? [];
+  const isVerb = tags.includes("Verb");
+  const isNounOrAdjective = tags.includes("Noun") || tags.includes("Adjective");
+  return !isVerb || isNounOrAdjective;
+}
+function getOccurrenceFromMatch(entry, originalText) {
+  const terms = entry.terms;
+  if (!terms?.length) return null;
+  const firstOffset = terms[0].offset;
+  const lastOffset = terms[terms.length - 1].offset;
+  if (typeof firstOffset?.start !== "number" || typeof firstOffset.length !== "number" || typeof lastOffset?.start !== "number" || typeof lastOffset.length !== "number") {
+    return null;
+  }
+  const start = firstOffset.start;
+  const end = lastOffset.start + lastOffset.length;
+  if (end <= start) return null;
+  return {
+    text: originalText.slice(start, end),
+    start,
+    end
+  };
+}
+var noNonInclusiveLanguage = {
+  id: "no-non-inclusive-language-nlp",
+  description: "Flag non-inclusive terms and suggest neutral alternatives using NLP-aware matching",
+  defaults: { terms: DEFAULT_TERMS2, allowedTerms: [] },
+  help: "Non-inclusive terms can alienate readers. Replace them with neutral alternatives that name the same idea without relying on identity, ability, or historical power metaphors.",
+  check({ text, sourceMap, options }) {
+    const terms = options.terms?.length ? options.terms : DEFAULT_TERMS2;
+    const allowed = new Set((options.allowedTerms ?? []).map((term) => term.toLowerCase()));
+    const doc = createDoc(text);
+    const diagnostics = [];
+    for (const term of terms) {
+      if (allowed.has(term.term.toLowerCase())) continue;
+      const pattern = toMatchPattern(term.term);
+      const matches = doc.match(pattern);
+      const json = matches.json({ offset: true, text: true, terms: { offset: true, text: true, tags: true } });
+      for (const entry of json) {
+        if (!isProblematicUsage(term, entry.terms ?? [])) continue;
+        const occurrence = getOccurrenceFromMatch(entry, text);
+        if (!occurrence) continue;
+        const range = getOccurrenceRange(sourceMap, occurrence);
+        if (!range) continue;
+        const suggestion = term.alternatives.join(", ");
+        diagnostics.push({
+          ruleId: "no-non-inclusive-language-nlp",
+          severity: "error",
+          message: `replace "${occurrence.text}" with a neutral alternative such as "${suggestion}"`,
+          range,
+          help: noNonInclusiveLanguage.help
+        });
+      }
+    }
+    return diagnostics.sort((left, right) => left.range.start - right.range.start);
+  }
+};
+
 // src/no-nominalized-phrases.ts
 var DEFAULT_SUFFIXES = ["tion", "sion", "ment", "ance", "ence", "ity"];
 var DEFAULT_ALLOWED_WORDS = [
@@ -459,6 +741,192 @@ function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/no-overly-complex-sentences.ts
+var DEFAULT_MAX_CONJUNCTIONS = 4;
+var DEFAULT_MAX_COORDINATING = 3;
+var DEFAULT_MAX_SUBORDINATING = 2;
+var DEFAULT_COORDINATING = ["and", "but", "or", "nor", "yet", "so"];
+var DEFAULT_SUBORDINATING = [
+  "because",
+  "although",
+  "though",
+  "while",
+  "since",
+  "unless",
+  "if",
+  "when",
+  "after",
+  "before",
+  "until",
+  "whether",
+  "once"
+];
+var noOverlyComplexSentences = {
+  id: "no-overly-complex-sentences",
+  description: "Flag sentences with too many coordinating or subordinating conjunctions",
+  defaults: {
+    maxConjunctions: DEFAULT_MAX_CONJUNCTIONS,
+    maxCoordinating: DEFAULT_MAX_COORDINATING,
+    maxSubordinating: DEFAULT_MAX_SUBORDINATING,
+    coordinating: DEFAULT_COORDINATING,
+    subordinating: DEFAULT_SUBORDINATING,
+    allowList: []
+  },
+  help: "Sentences packed with conjunctions are often run-ons or nested too deeply. Break them into shorter sentences so each point stands on its own.",
+  check({ text, sourceMap, options }) {
+    const maxConjunctions = options.maxConjunctions ?? DEFAULT_MAX_CONJUNCTIONS;
+    const maxCoordinating = options.maxCoordinating ?? DEFAULT_MAX_COORDINATING;
+    const maxSubordinating = options.maxSubordinating ?? DEFAULT_MAX_SUBORDINATING;
+    const coordinating = (options.coordinating ?? DEFAULT_COORDINATING).map(
+      (value) => value.toLowerCase().trim()
+    );
+    const subordinating = (options.subordinating ?? DEFAULT_SUBORDINATING).map(
+      (value) => value.toLowerCase().trim()
+    );
+    const allowList = new Set(
+      (options.allowList ?? []).map((value) => value.toLowerCase().trim())
+    );
+    const patterns = [
+      ...coordinating.map((phrase) => ({
+        phrase,
+        category: "coordinating",
+        regex: phraseToRegex(phrase)
+      })),
+      ...subordinating.map((phrase) => ({
+        phrase,
+        category: "subordinating",
+        regex: phraseToRegex(phrase)
+      }))
+    ].sort((a, b) => b.phrase.length - a.phrase.length);
+    const doc = createDoc(text);
+    const sentences = doc.sentences().json({ offset: true, terms: { offset: true } });
+    const diagnostics = [];
+    for (const sentence of sentences) {
+      if (!sentence.offset || !sentence.terms) continue;
+      const sentenceStart = sentence.offset.start ?? 0;
+      const sentenceText = sentence.text ?? "";
+      const matchedRanges = [];
+      let coordinatingCount = 0;
+      let subordinatingCount = 0;
+      for (const { phrase, category, regex } of patterns) {
+        if (allowList.has(phrase)) continue;
+        let match;
+        while ((match = regex.exec(sentenceText)) !== null) {
+          const matchStart = match.index;
+          const matchEnd = match.index + match[0].length;
+          if (matchedRanges.some((range) => matchStart < range.end && matchEnd > range.start)) {
+            continue;
+          }
+          matchedRanges.push({ start: matchStart, end: matchEnd });
+          if (category === "coordinating") {
+            coordinatingCount += 1;
+          } else {
+            subordinatingCount += 1;
+          }
+        }
+      }
+      const total = coordinatingCount + subordinatingCount;
+      if (total <= maxConjunctions && coordinatingCount <= maxCoordinating && subordinatingCount <= maxSubordinating) {
+        continue;
+      }
+      const length = sentence.offset.length ?? 0;
+      const sentenceEnd = sentenceStart + length;
+      const sourceStart = sourceMap[sentenceStart];
+      const sourceEnd = sourceMap[sentenceEnd - 1];
+      if (sourceStart === void 0 || sourceEnd === void 0) continue;
+      const reasons = [];
+      if (total > maxConjunctions) {
+        reasons.push(`${total} conjunctions (max ${maxConjunctions})`);
+      }
+      if (coordinatingCount > maxCoordinating) {
+        reasons.push(`${coordinatingCount} coordinating (max ${maxCoordinating})`);
+      }
+      if (subordinatingCount > maxSubordinating) {
+        reasons.push(`${subordinatingCount} subordinating (max ${maxSubordinating})`);
+      }
+      diagnostics.push({
+        ruleId: "no-overly-complex-sentences",
+        severity: "warn",
+        message: `sentence is overly complex: ${reasons.join(", ")} \u2014 consider splitting it`,
+        range: { start: sourceStart, end: sourceEnd + 1 },
+        help: noOverlyComplexSentences.help,
+        suggest: {
+          description: "Split this sentence into shorter sentences, one idea each.",
+          edits: []
+        }
+      });
+    }
+    return diagnostics;
+  }
+};
+function phraseToRegex(phrase) {
+  const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const spaced = escaped.replace(/\s+/g, "\\s+");
+  const source = spaced.includes("\\s+") ? spaced : `\\b${spaced}\\b`;
+  return new RegExp(source, "gi");
+}
+
+// src/no-overused-adverbs.ts
+var DEFAULT_THRESHOLD = 3;
+var DEFAULT_MIN_LENGTH = 3;
+var DEFAULT_ALLOWED_ADVERBS2 = ["only", "not"];
+var noOverusedAdverbs = {
+  id: "no-overused-adverbs",
+  description: "Flag adverbs that appear excessively across the text",
+  defaults: {
+    threshold: DEFAULT_THRESHOLD,
+    minLength: DEFAULT_MIN_LENGTH,
+    allowedAdverbs: DEFAULT_ALLOWED_ADVERBS2
+  },
+  help: "Repeating the same adverb throughout a passage weakens copy and reads as filler. Replace the adverb with a stronger verb or adjective, cut it, or add it to allowedAdverbs if it is essential.",
+  check({ text, sourceMap, options }) {
+    const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+    const minLength = options.minLength ?? DEFAULT_MIN_LENGTH;
+    const allowed = new Set((options.allowedAdverbs ?? DEFAULT_ALLOWED_ADVERBS2).map((value) => value.toLowerCase()));
+    const adverbFilter = options.adverbs ? new Set(options.adverbs.map((value) => value.toLowerCase())) : null;
+    const doc = createDoc(text);
+    const sentences = doc.json({ offset: true, terms: { offset: true, tags: true } });
+    const occurrencesByAdverb = /* @__PURE__ */ new Map();
+    for (const sentence of sentences) {
+      for (const term of sentence.terms ?? []) {
+        if (!term.tags?.includes("Adverb")) continue;
+        const rawText = term.text?.replace(/[^a-zA-Z]+$/, "") ?? "";
+        const normalized = rawText.toLowerCase();
+        if (!normalized || normalized.length < minLength) continue;
+        if (allowed.has(normalized)) continue;
+        if (adverbFilter && !adverbFilter.has(normalized)) continue;
+        const start = term.offset?.start;
+        const length = term.offset?.length;
+        if (typeof start !== "number" || typeof length !== "number") continue;
+        const occurrence = { text: rawText, start, end: start + length };
+        const existing = occurrencesByAdverb.get(normalized);
+        if (existing) {
+          existing.push(occurrence);
+        } else {
+          occurrencesByAdverb.set(normalized, [occurrence]);
+        }
+      }
+    }
+    const diagnostics = [];
+    for (const [, occurrences] of occurrencesByAdverb) {
+      if (occurrences.length <= threshold) continue;
+      for (let index = threshold; index < occurrences.length; index += 1) {
+        const occurrence = occurrences[index];
+        const range = getOccurrenceRange(sourceMap, occurrence);
+        if (!range) continue;
+        diagnostics.push({
+          ruleId: "no-overused-adverbs",
+          severity: "warn",
+          message: `reduce overused adverb: "${occurrence.text}" appears ${occurrences.length} times`,
+          range,
+          help: noOverusedAdverbs.help
+        });
+      }
+    }
+    return diagnostics.sort((left, right) => left.range.start - right.range.start);
+  }
+};
+
 // src/no-passive-voice.ts
 var DEFAULT_ALLOWED_AUXILIARIES = ["is", "are", "was", "were", "be", "been", "being"];
 var noPassiveVoice = {
@@ -549,6 +1017,65 @@ function escapeRegex3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/no-qualifier-creep.ts
+var DEFAULT_QUALIFIERS = [
+  "very",
+  "really",
+  "quite",
+  "fairly",
+  "somewhat",
+  "rather",
+  "pretty",
+  "basically",
+  "actually",
+  "literally",
+  "essentially",
+  "truly",
+  "definitely",
+  "clearly",
+  "obviously",
+  "absolutely",
+  "completely",
+  "totally",
+  "utterly"
+];
+var DEFAULT_MAX_QUALIFIERS = 1;
+var noQualifierCreep = {
+  id: "no-qualifier-creep",
+  description: "Flag stacked qualifiers or intensifiers before an adjective or adverb",
+  defaults: { qualifiers: DEFAULT_QUALIFIERS, maxQualifiers: DEFAULT_MAX_QUALIFIERS },
+  help: "Stacked qualifiers dilute the claim and feel hedged. Keep the strongest qualifier or replace the phrase with concrete evidence.",
+  check({ text, sourceMap, options }) {
+    const qualifiers = new Set((options.qualifiers?.length ? options.qualifiers : DEFAULT_QUALIFIERS).map((value) => value.toLowerCase()));
+    const maxQualifiers = options.maxQualifiers ?? DEFAULT_MAX_QUALIFIERS;
+    if (maxQualifiers < 1) return [];
+    const doc = createDoc(text);
+    const diagnostics = [];
+    const seenRanges = [];
+    const patterns = ["#Adverb #Adverb+ #Adjective", "#Adverb #Adverb+ #Adverb"];
+    for (const pattern of patterns) {
+      const matches = doc.match(pattern);
+      for (const occurrence of getMatchOccurrences(text, matches)) {
+        const words = occurrence.text.trim().split(/\s+/);
+        const qualifierWords = words.filter((word) => qualifiers.has(word.toLowerCase().replace(/[^a-zA-Z]+$/, "")));
+        if (qualifierWords.length <= maxQualifiers) continue;
+        if (seenRanges.some((range2) => occurrence.start < range2.end && occurrence.end > range2.start)) continue;
+        seenRanges.push({ start: occurrence.start, end: occurrence.end });
+        const range = getOccurrenceRange(sourceMap, occurrence);
+        if (!range) continue;
+        diagnostics.push({
+          ruleId: "no-qualifier-creep",
+          severity: "warn",
+          message: `remove stacked qualifiers in "${occurrence.text}" \u2014 use one strong word or a concrete detail`,
+          range,
+          help: noQualifierCreep.help
+        });
+      }
+    }
+    return diagnostics.sort((left, right) => left.range.start - right.range.start);
+  }
+};
+
 // src/no-redundant-pairs.ts
 var DEFAULT_PHRASES5 = [
   "first and foremost",
@@ -570,7 +1097,7 @@ var noRedundantPairs = {
     const diagnostics = [];
     const phrases = options.phrases?.length ? options.phrases : DEFAULT_PHRASES5;
     for (const phrase of phrases) {
-      const re = new RegExp(`\\b${escapeRegExp5(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp6(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const matchedPhrase = match[0];
@@ -589,7 +1116,7 @@ var noRedundantPairs = {
     return diagnostics;
   }
 };
-function escapeRegExp5(value) {
+function escapeRegExp6(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -644,7 +1171,7 @@ var noSuperlativeClaims = {
     );
     const claimedRanges = [];
     for (const phrase of phrases) {
-      const re = new RegExp(`\\b${escapeRegExp6(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
+      const re = new RegExp(`\\b${escapeRegExp7(phrase).replace(/\\s+/g, "\\s+")}\\b`, "gi");
       let match;
       while ((match = re.exec(text)) !== null) {
         const matchedPhrase = match[0];
@@ -673,10 +1200,89 @@ function getLongestPhrasesFirst(phrases) {
 function rangesOverlap(range, start, end) {
   return start < range.end && end > range.start;
 }
-function escapeRegExp6(value) {
+function escapeRegExp7(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/no-vague-comparatives.ts
+import nlp2 from "compromise";
+var DEFAULT_OPTIONS2 = {
+  comparatives: [
+    "better",
+    "worse",
+    "more",
+    "less",
+    "faster",
+    "slower",
+    "easier",
+    "harder",
+    "stronger",
+    "weaker",
+    "higher",
+    "lower",
+    "bigger",
+    "smaller",
+    "greater"
+  ],
+  requireThan: true
+};
+var noVagueComparatives = {
+  id: "no-vague-comparatives",
+  description: "Flag comparative claims that omit a clear baseline",
+  defaults: { ...DEFAULT_OPTIONS2 },
+  help: 'Comparative words like "better" or "faster" only persuade when the reader knows what is being compared. Add "than" and a concrete baseline, or rephrase with a specific metric.',
+  check({ text, sourceMap, options }) {
+    const comparatives = new Set(
+      (options.comparatives ?? DEFAULT_OPTIONS2.comparatives).map((word) => word.toLowerCase())
+    );
+    const requireThan = options.requireThan ?? DEFAULT_OPTIONS2.requireThan;
+    if (comparatives.size === 0) return [];
+    const doc = nlp2(text);
+    const diagnostics = [];
+    const seenRanges = [];
+    const sentences = doc.sentences().json({ offset: true, terms: { offset: true, text: true } });
+    for (const sentence of sentences) {
+      const sentenceStart = sentence.offset?.start ?? sentence.terms?.[0]?.offset?.start;
+      const sentenceLength = sentence.offset?.length ?? sentence.terms?.reduce((sum, term) => sum + (term.offset?.length ?? 0), 0);
+      if (typeof sentenceStart !== "number" || typeof sentenceLength !== "number") continue;
+      const sentenceEnd = sentenceStart + sentenceLength;
+      const sentenceText = sentence.text ?? text.slice(sentenceStart, sentenceEnd);
+      const sentenceDoc = nlp2(sentenceText);
+      const explicitComparatives = Array.from(comparatives).join("|");
+      const patterns = [
+        "#Comparative",
+        `(more|less) #Adjective`,
+        `(more|less) #Adverb`,
+        `(${explicitComparatives})`
+      ];
+      for (const pattern of patterns) {
+        const matches = sentenceDoc.match(pattern);
+        for (const occurrence of getMatchOccurrences(sentenceText, matches)) {
+          const words = occurrence.text.trim().toLowerCase().split(/\s+/);
+          const matchedComparative = words.find((word) => comparatives.has(word.replace(/[^a-zA-Z]+$/, "")));
+          if (!matchedComparative) continue;
+          const trailingPunctuation = occurrence.text.match(/[^a-zA-Z\s]+$/)?.[0].length ?? 0;
+          const occurrenceStart = sentenceStart + occurrence.start;
+          const occurrenceEnd = sentenceStart + occurrence.end - trailingPunctuation;
+          if (seenRanges.some((range2) => occurrenceStart < range2.end && occurrenceEnd > range2.start)) continue;
+          seenRanges.push({ start: occurrenceStart, end: occurrenceEnd });
+          if (requireThan && sentenceDoc.has("than")) continue;
+          const range = getOccurrenceRange(sourceMap, { text: occurrence.text, start: occurrenceStart, end: occurrenceEnd });
+          if (!range) continue;
+          diagnostics.push({
+            ruleId: "no-vague-comparatives",
+            severity: "warn",
+            message: `comparative "${occurrence.text.trim().replace(/[^a-zA-Z\s]+$/, "")}" needs a baseline \u2014 add "than" or a concrete comparison`,
+            range,
+            help: noVagueComparatives.help
+          });
+        }
+      }
+    }
+    return diagnostics.sort((left, right) => left.range.start - right.range.start);
+  }
+};
+
 // src/no-vague-quantifiers.ts
 var DEFAULT_QUANTIFIERS = [
   "many",
@@ -703,7 +1309,7 @@ var noVagueQuantifiers = {
     const quantifiers = options.quantifiers?.length ? options.quantifiers : DEFAULT_QUANTIFIERS;
     for (const quantifier of quantifiers) {
       const re = new RegExp(
-        `\\b${escapeRegExp7(quantifier).replace(/\\s+/g, "\\s+")}\\b`,
+        `\\b${escapeRegExp8(quantifier).replace(/\\s+/g, "\\s+")}\\b`,
         "gi"
       );
       let match;
@@ -724,7 +1330,7 @@ var noVagueQuantifiers = {
     return diagnostics;
   }
 };
-function escapeRegExp7(value) {
+function escapeRegExp8(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -773,9 +1379,62 @@ var noWeakModals = {
   }
 };
 
+// src/sentence-complexity.ts
+var DEFAULT_OPTIONS3 = {
+  maxWordCount: 25,
+  maxClauseCount: 3
+};
+var sentenceComplexity = {
+  id: "sentence-complexity",
+  description: "Flag sentences that exceed a word or clause threshold",
+  defaults: { ...DEFAULT_OPTIONS3 },
+  help: "Long, clause-heavy sentences are harder to read. Split them into shorter sentences that each make one point.",
+  check({ text, sourceMap, options }) {
+    const maxWordCount = options.maxWordCount ?? DEFAULT_OPTIONS3.maxWordCount;
+    const maxClauseCount = options.maxClauseCount ?? DEFAULT_OPTIONS3.maxClauseCount;
+    const doc = createDoc(text);
+    const sentences = doc.sentences().json({ offset: true, terms: { offset: true, tags: true } });
+    const diagnostics = [];
+    for (const sentence of sentences) {
+      if (!sentence.offset || !sentence.terms) continue;
+      const terms = sentence.terms.filter((term) => /[a-zA-Z0-9]/.test(term.text ?? ""));
+      const wordCount = terms.length;
+      const clauseCount = terms.filter((term) => {
+        const tags = term.tags ?? [];
+        return tags.includes("Verb") && !tags.includes("Gerund") && !tags.includes("Infinitive") && !tags.includes("Particle");
+      }).length;
+      if (wordCount <= maxWordCount && clauseCount <= maxClauseCount) continue;
+      const start = sentence.offset.start ?? 0;
+      const length = sentence.offset.length ?? 0;
+      const end = start + length;
+      const sourceStart = sourceMap[start];
+      const sourceEnd = sourceMap[end - 1];
+      if (sourceStart === void 0 || sourceEnd === void 0) continue;
+      const reasons = [];
+      if (wordCount > maxWordCount) reasons.push(`${wordCount} words (max ${maxWordCount})`);
+      if (clauseCount > maxClauseCount) reasons.push(`${clauseCount} clauses (max ${maxClauseCount})`);
+      diagnostics.push({
+        ruleId: "sentence-complexity",
+        severity: "warn",
+        message: `sentence is too complex: ${reasons.join(", ")} \u2014 consider splitting it`,
+        range: { start: sourceStart, end: sourceEnd + 1 },
+        help: sentenceComplexity.help,
+        suggest: {
+          description: "Split this sentence into shorter sentences, one idea each.",
+          edits: []
+        }
+      });
+    }
+    return diagnostics;
+  }
+};
+
 // src/index.ts
 var ruleRegistry = /* @__PURE__ */ new Map([
+  ["no-absolute-intensifiers", noAbsoluteIntensifiers],
+  ["no-adverb-overuse", noAdverbOveruse],
   ["no-buzzword-stacks", noBuzzwordStacks],
+  ["no-complex-readability", noComplexReadability],
   ["no-empty-transformation-claims", noEmptyTransformationClaims],
   ["no-expletive-openers", noExpletiveOpeners],
   ["no-filter-words", noFilterWords],
@@ -783,17 +1442,26 @@ var ruleRegistry = /* @__PURE__ */ new Map([
   ["no-hedge-words", noHedgeWords],
   ["no-jargon", noJargon],
   ["no-meaningless-modifiers", noMeaninglessModifiers],
+  ["no-non-inclusive-language-nlp", noNonInclusiveLanguage],
   ["no-nominalized-phrases", noNominalizedPhrases],
+  ["no-overly-complex-sentences", noOverlyComplexSentences],
+  ["no-overused-adverbs", noOverusedAdverbs],
   ["no-passive-voice", noPassiveVoice],
   ["no-pronoun-led-claims", noPronounLedClaims],
+  ["no-qualifier-creep", noQualifierCreep],
   ["no-redundant-pairs", noRedundantPairs],
   ["no-stacked-adjectives", noStackedAdjectives],
   ["no-superlative-claims", noSuperlativeClaims],
+  ["no-vague-comparatives", noVagueComparatives],
   ["no-vague-quantifiers", noVagueQuantifiers],
-  ["no-weak-modals", noWeakModals]
+  ["no-weak-modals", noWeakModals],
+  ["sentence-complexity", sentenceComplexity]
 ]);
 export {
+  noAbsoluteIntensifiers,
+  noAdverbOveruse,
   noBuzzwordStacks,
+  noComplexReadability,
   noEmptyTransformationClaims,
   noExpletiveOpeners,
   noFilterWords,
@@ -802,13 +1470,19 @@ export {
   noJargon,
   noMeaninglessModifiers,
   noNominalizedPhrases,
+  noNonInclusiveLanguage,
+  noOverlyComplexSentences,
+  noOverusedAdverbs,
   noPassiveVoice,
   noPronounLedClaims,
+  noQualifierCreep,
   noRedundantPairs,
   noStackedAdjectives,
   noSuperlativeClaims,
+  noVagueComparatives,
   noVagueQuantifiers,
   noWeakModals,
-  ruleRegistry
+  ruleRegistry,
+  sentenceComplexity
 };
 //# sourceMappingURL=index.js.map