opengrammar-server 2.0.615350

package/src/rules/categories/readability.ts

@@ -0,0 +1,293 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ═══════════════════════════════════════════════════
+ *  Readability & Simplification (RD)
+ *  Complex words, sentence length, paragraph length
+ * ═══════════════════════════════════════════════════
+ */
+export const readabilityRules: Rule[] = [
+  // ═══ Complex Word Simplification (RD_003) ═══
+  createRegexRule({
+    id: 'RD_utilize',
+    category: 'clarity',
+    pattern: /\butilize\b/i,
+    suggestion: 'use',
+    reason: '"Utilize" can almost always be replaced with the simpler "use".',
+  }),
+  createRegexRule({
+    id: 'RD_demonstrate',
+    category: 'clarity',
+    pattern: /\bdemonstrate\b/i,
+    suggestion: 'show',
+    reason: '"Demonstrate" can often be simplified to "show".',
+  }),
+  createRegexRule({
+    id: 'RD_approximately',
+    category: 'clarity',
+    pattern: /\bapproximately\b/i,
+    suggestion: 'about',
+    reason: '"Approximately" can be simplified to "about" or "roughly".',
+  }),
+  createRegexRule({
+    id: 'RD_subsequent',
+    category: 'clarity',
+    pattern: /\bsubsequent\b/i,
+    suggestion: 'next',
+    reason: '"Subsequent" can be simplified to "next" or "following".',
+  }),
+  createRegexRule({
+    id: 'RD_prior_to',
+    category: 'clarity',
+    pattern: /\bprior\s+to\b/i,
+    suggestion: 'before',
+    reason: '"Prior to" can be simplified to "before".',
+  }),
+  createRegexRule({
+    id: 'RD_sufficient',
+    category: 'clarity',
+    pattern: /\bsufficient\b/i,
+    suggestion: 'enough',
+    reason: '"Sufficient" can be simplified to "enough".',
+  }),
+  createRegexRule({
+    id: 'RD_nevertheless',
+    category: 'clarity',
+    pattern: /\bnevertheless\b/i,
+    suggestion: 'still',
+    reason: '"Nevertheless" can often be simplified to "still", "yet", or "however".',
+  }),
+  createRegexRule({
+    id: 'RD_notwithstanding',
+    category: 'clarity',
+    pattern: /\bnotwithstanding\b/i,
+    suggestion: 'despite',
+    reason: '"Notwithstanding" can be simplified to "despite" or "in spite of".',
+  }),
+  createRegexRule({
+    id: 'RD_heretofore',
+    category: 'clarity',
+    pattern: /\bheretofore\b/i,
+    suggestion: 'previously',
+    reason: '"Heretofore" is archaic. Use "previously" or "until now".',
+  }),
+  createRegexRule({
+    id: 'RD_aforementioned',
+    category: 'clarity',
+    pattern: /\baforementioned\b/i,
+    suggestion: 'previous',
+    reason: '"Aforementioned" is overly formal. Use "previous", "earlier", or just name the thing.',
+  }),
+  createRegexRule({
+    id: 'RD_inasmuch',
+    category: 'clarity',
+    pattern: /\binasmuch\s+as\b/i,
+    suggestion: 'since',
+    reason: '"Inasmuch as" is archaic. Use "since" or "because".',
+  }),
+  createRegexRule({
+    id: 'RD_henceforth',
+    category: 'clarity',
+    pattern: /\bhenceforth\b/i,
+    suggestion: 'from now on',
+    reason: '"Henceforth" is archaic. Use "from now on".',
+  }),
+  createRegexRule({
+    id: 'RD_moreover',
+    category: 'clarity',
+    pattern: /\bmoreover\b/i,
+    suggestion: 'also',
+    reason: '"Moreover" can usually be simplified to "also" or "besides".',
+  }),
+  createRegexRule({
+    id: 'RD_furthermore',
+    category: 'clarity',
+    pattern: /\bfurthermore\b/i,
+    suggestion: 'also',
+    reason: '"Furthermore" can usually be simplified to "also" or "in addition".',
+  }),
+  createRegexRule({
+    id: 'RD_consequently',
+    category: 'clarity',
+    pattern: /\bconsequently\b/i,
+    suggestion: 'so',
+    reason: '"Consequently" can often be simplified to "so" or "as a result".',
+  }),
+  createRegexRule({
+    id: 'RD_predominantly',
+    category: 'clarity',
+    pattern: /\bpredominantly\b/i,
+    suggestion: 'mainly',
+    reason: '"Predominantly" can be simplified to "mainly" or "mostly".',
+  }),
+  createRegexRule({
+    id: 'RD_necessitate',
+    category: 'clarity',
+    pattern: /\bnecessitate\b/i,
+    suggestion: 'require',
+    reason: '"Necessitate" can be simplified to "require" or "need".',
+  }),
+  createRegexRule({
+    id: 'RD_endeavour',
+    category: 'clarity',
+    pattern: /\bendeavou?r\b/i,
+    suggestion: 'try',
+    reason: '"Endeavor" is unnecessarily formal. Use "try" or "attempt".',
+  }),
+  createRegexRule({
+    id: 'RD_commensurate',
+    category: 'clarity',
+    pattern: /\bcommensurate\b/i,
+    suggestion: 'proportional',
+    reason: '"Commensurate" can be simplified to "proportional" or "matching".',
+  }),
+  createRegexRule({
+    id: 'RD_multifaceted',
+    category: 'clarity',
+    pattern: /\bmultifaceted\b/i,
+    suggestion: 'complex',
+    reason: '"Multifaceted" can be simplified to "complex" or "varied".',
+  }),
+  createRegexRule({
+    id: 'RD_dichotomy',
+    category: 'clarity',
+    pattern: /\bdichotomy\b/i,
+    suggestion: 'divide',
+    reason: '"Dichotomy" can be simplified to "divide", "split", or "contrast".',
+  }),
+  createRegexRule({
+    id: 'RD_ubiquitous',
+    category: 'clarity',
+    pattern: /\bubiquitous\b/i,
+    suggestion: 'widespread',
+    reason: '"Ubiquitous" can be simplified to "widespread" or "everywhere".',
+  }),
+  createRegexRule({
+    id: 'RD_juxtapose',
+    category: 'clarity',
+    pattern: /\bjuxtapose\b/i,
+    suggestion: 'compare',
+    reason: '"Juxtapose" can be simplified to "compare" or "place side by side".',
+  }),
+  createRegexRule({
+    id: 'RD_ameliorate',
+    category: 'clarity',
+    pattern: /\bameliorate\b/i,
+    suggestion: 'improve',
+    reason: '"Ameliorate" can be simplified to "improve" or "make better".',
+  }),
+  createRegexRule({
+    id: 'RD_exacerbate',
+    category: 'clarity',
+    pattern: /\bexacerbate\b/i,
+    suggestion: 'worsen',
+    reason: '"Exacerbate" can be simplified to "worsen" or "make worse".',
+  }),
+  createRegexRule({
+    id: 'RD_proliferate',
+    category: 'clarity',
+    pattern: /\bproliferate\b/i,
+    suggestion: 'spread',
+    reason: '"Proliferate" can be simplified to "spread" or "increase rapidly".',
+  }),
+  createRegexRule({
+    id: 'RD_myriad',
+    category: 'clarity',
+    pattern: /\ba\s+myriad\s+of\b/i,
+    suggestion: 'many',
+    reason: '"A myriad of" is wordy. Use "many" or "countless". (Or: "myriad" without "a...of").',
+  }),
+  createRegexRule({
+    id: 'RD_plethora',
+    category: 'clarity',
+    pattern: /\ba\s+plethora\s+of\b/i,
+    suggestion: 'many',
+    reason: '"A plethora of" is wordy. Use "many", "plenty of", or "an abundance of".',
+  }),
+  createRegexRule({
+    id: 'RD_quintessential',
+    category: 'clarity',
+    pattern: /\bquintessential\b/i,
+    suggestion: 'classic',
+    reason: '"Quintessential" can be simplified to "classic", "ideal", or "perfect example of".',
+  }),
+  createRegexRule({
+    id: 'RD_paradigm',
+    category: 'clarity',
+    pattern: /\bparadigm\b/i,
+    suggestion: 'model',
+    reason: '"Paradigm" is overused jargon. Use "model", "framework", or "pattern".',
+  }),
+
+  // ═══ Very Long Sentences (RD_001) ═══
+  {
+    id: 'RD_long_sentence',
+    type: 'regex',
+    category: 'clarity',
+    pattern: /[^.!?]+[.!?]+/g,
+    reason: 'Very long sentence detected.',
+    suggestion: 'Consider breaking this into shorter sentences.',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+      let offset = 0;
+      for (const sentence of sentences) {
+        const wordCount = sentence.trim().split(/\s+/).length;
+        if (wordCount > 40) {
+          issues.push({
+            id: `RD_long_sentence-${offset}`,
+            type: 'clarity',
+            original: sentence.trim().substring(0, 60) + '...',
+            suggestion: 'Consider breaking this into shorter sentences.',
+            reason: `This sentence has ${wordCount} words. Sentences over 40 words are difficult to read.`,
+            offset,
+            length: sentence.length,
+          });
+        }
+        offset += sentence.length;
+      }
+      return issues;
+    },
+  },
+
+  // ═══ Repeated Sentence Beginnings (RD_005) ═══
+  {
+    id: 'RD_repeated_starts',
+    type: 'regex',
+    category: 'style',
+    pattern: /[^.!?]+[.!?]+/g,
+    reason: 'Repeated sentence beginnings reduce readability.',
+    suggestion: 'Vary your sentence openings.',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+      if (sentences.length < 3) return issues;
+
+      let offset = 0;
+      for (let i = 2; i < sentences.length; i++) {
+        const getStart = (s: string) => (s.trim().split(/\s+/)[0] || '').toLowerCase();
+        const w1 = getStart(sentences[i - 2] || '');
+        const w2 = getStart(sentences[i - 1] || '');
+        const w3 = getStart(sentences[i] || '');
+
+        if (w1 && w1 === w2 && w2 === w3 && !['the', 'a', 'an', 'i'].includes(w1)) {
+          const sentenceOffset = text.indexOf((sentences[i] || '').trim(), offset);
+          if (sentenceOffset >= 0) {
+            issues.push({
+              id: `RD_repeated_starts-${sentenceOffset}`,
+              type: 'style',
+              original: (sentences[i] || '').trim().substring(0, 40) + '...',
+              suggestion: 'Vary your sentence openings for better flow.',
+              reason: `Three consecutive sentences start with "${w1}". Vary your sentence beginnings.`,
+              offset: sentenceOffset,
+              length: (sentences[i] || '').trim().length,
+            });
+          }
+        }
+        offset += (sentences[i - 2] || '').length;
+      }
+      return issues;
+    },
+  },
+];

package/src/rules/categories/sentence-structure.ts

@@ -0,0 +1,100 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const sentenceStructureRules: Rule[] = [
+  // ═══ Subject-Verb Agreement (SS_SVA) ═══
+
+  // SS_SVA_001 — Singular subjects with plural verbs
+  createRegexRule({
+    id: 'SS_SVA_001a',
+    category: 'grammar',
+    pattern:
+      /\b(he|she|it)\s+(are|were|have|do|go|need|want|make|take|come|give|say|seem|know|think)\b/i,
+    suggestion: (m) =>
+      `${m[1]} ${({ are: 'is', were: 'was', have: 'has', do: 'does', go: 'goes', need: 'needs', want: 'wants', make: 'makes', take: 'takes', come: 'comes', give: 'gives', say: 'says', seem: 'seems', know: 'knows', think: 'thinks' } as Record<string, string>)[(m[2] || '').toLowerCase()] || m[2]}`,
+    reason: 'Singular subject requires a singular verb.',
+  }),
+
+  // SS_SVA_003 — Indefinite pronouns + plural verbs
+  createRegexRule({
+    id: 'SS_SVA_003a',
+    category: 'grammar',
+    pattern:
+      /\b(everyone|someone|anybody|somebody|nobody|no\s+one|each|either|neither)\s+(are|were|have|do|go|seem|need|want)\b/i,
+    suggestion: (m) =>
+      `${m[1]} ${({ are: 'is', were: 'was', have: 'has', do: 'does', go: 'goes', seem: 'seems', need: 'needs', want: 'wants' } as Record<string, string>)[(m[2] || '').toLowerCase()] || m[2]}`,
+    reason: 'Indefinite pronouns (everyone, someone, each, neither, etc.) take singular verbs.',
+  }),
+
+  // SS_SVA_004 — Collective nouns (AmE singular)
+  createRegexRule({
+    id: 'SS_SVA_004a',
+    category: 'grammar',
+    pattern:
+      /\b(the\s+)?(team|committee|family|group|staff|jury|audience|crowd|class|government|company|board|council|panel)\s+(are|were|have|do)\b/i,
+    suggestion: (m) =>
+      `${m[1] || ''}${m[2]} ${({ are: 'is', were: 'was', have: 'has', do: 'does' } as Record<string, string>)[(m[3] || '').toLowerCase()] || m[3]}`,
+    reason: 'Collective nouns take singular verbs in American English.',
+  }),
+
+  // SS_SVA_007 — There is/are agreement
+  createRegexRule({
+    id: 'SS_SVA_007a',
+    category: 'grammar',
+    pattern:
+      /\bthere\s+is\s+(many|several|numerous|various|multiple|two|three|four|five|six|seven|eight|nine|ten)\b/i,
+    suggestion: (m) => `there are ${m[1]}`,
+    reason: 'Use "are" with plural subjects after "there".',
+  }),
+  createRegexRule({
+    id: 'SS_SVA_007b',
+    category: 'grammar',
+    pattern:
+      /\bthere\s+was\s+(many|several|numerous|various|multiple|two|three|four|five|six|seven|eight|nine|ten)\b/i,
+    suggestion: (m) => `there were ${m[1]}`,
+    reason: 'Use "were" with plural subjects after "there".',
+  }),
+
+  // ═══ Double Subjects (SS_DBS) ═══
+  createRegexRule({
+    id: 'SS_DBS_001a',
+    category: 'grammar',
+    pattern:
+      /\b(my\s+\w+|the\s+\w+)\s+(he|she|it|they)\s+(is|are|was|were|has|have|does|do|will|would|can|could|should|shall|might|must)\b/i,
+    suggestion: (m) => `${m[1]} ${m[3]}`,
+    reason: 'Redundant pronoun after noun subject. Remove the extra pronoun.',
+  }),
+
+  // ═══ Faulty Predication (SS_FPR) ═══
+  createRegexRule({
+    id: 'SS_FPR_001',
+    category: 'grammar',
+    pattern: /\bthe\s+reason\s+(is|was)\s+because\b/i,
+    suggestion: (m) => `the reason ${m[1]} that`,
+    reason: '"The reason is because" is redundant. Use "the reason is that".',
+  }),
+  createRegexRule({
+    id: 'SS_FPR_002',
+    category: 'grammar',
+    pattern:
+      /\b(the\s+problem|the\s+issue|the\s+question|the\s+difficulty)\s+(is|was)\s+(when|where|if)\b/i,
+    suggestion: (m) => `${m[1]} ${m[2]} that`,
+    reason: 'A noun subject should not be equated with an adverb clause. Use "that" instead.',
+  }),
+
+  // ═══ Parallel Structure with Correlatives (SS_PAR) ═══
+  createRegexRule({
+    id: 'SS_PAR_not_only',
+    category: 'grammar',
+    pattern: /\bnot\s+only\s+(\w+)\s+but\s+also\s+is\s+(\w+ing)\b/i,
+    suggestion: (m) => `not only ${m[1]} but also ${m[2]}`,
+    reason: 'Correlative conjunctions require parallel structure.',
+  }),
+  createRegexRule({
+    id: 'SS_PAR_both_and',
+    category: 'grammar',
+    pattern: /\bboth\s+likes?\s+to\s+(\w+)\s+and\s+(\w+ing)\b/i,
+    suggestion: (m) => `both ${m[1]}ing and ${m[2]}`,
+    reason: 'Items in "both...and" must be parallel — use the same grammatical form.',
+  }),
+];

package/src/rules/categories/spelling-advanced.ts

@@ -0,0 +1,164 @@
+import { createRegexRule, type Rule } from '../types.js';
+
+export const spellingAdvancedRules: Rule[] = [
+  // Confused Words
+  createRegexRule({
+    pattern: /\bthe\s+affect\b/i,
+    suggestion: 'the effect',
+    reason: 'Use "effect" (noun). "Affect" is usually a verb.',
+    id: 'confuse-the-affect',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\ban\s+affect\b/i,
+    suggestion: 'an effect',
+    reason: 'Use "effect" (noun). "Affect" is usually a verb.',
+    id: 'confuse-an-affect',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\bhas\s+no\s+affect\b/i,
+    suggestion: 'has no effect',
+    reason: 'Use "effect" (noun) here.',
+    id: 'confuse-no-affect',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\beffect\s+(the|a|his|her|their|our|my|your|its)\b/i,
+    suggestion: (m) => `affect ${m[1]}`,
+    reason: 'Use "affect" (verb) when meaning "to influence".',
+    id: 'effect-determiner',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern:
+      /\b(bigger|smaller|better|worse|more|less|faster|slower|higher|lower|greater|fewer|older|younger|earlier|later|longer|shorter|taller|stronger|weaker|easier|harder|smarter|richer|poorer|cheaper|nicer|closer)\s+then\b/i,
+    suggestion: (m) => `${m[1]} than`,
+    reason: 'Use "than" for comparisons, not "then".',
+    id: 'then-than',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\b(will|might|could|would|going to|gonna|dont want to|don't want to)\s+loose\b/i,
+    suggestion: (m) => `${m[1]} lose`,
+    reason: 'Use "lose" (verb, opposite of win/find). "Loose" means not tight.',
+    id: 'loose-lose',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern:
+      /\bexcept\s+(the|his|her|their|our|my|your|this|that|an?)\s+(offer|invitation|terms|conditions|award|gift|prize|challenge|proposal|request|apology|responsibility)\b/i,
+    suggestion: (m) => `accept ${m[1]} ${m[2]}`,
+    reason: 'Use "accept" (to receive). "Except" means excluding.',
+    id: 'except-accept',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bto\s+who\b/i,
+    suggestion: 'to whom',
+    reason: 'Use "whom" after a preposition (to, for, with, by).',
+    id: 'to-whom',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\bfor\s+who\b/i,
+    suggestion: 'for whom',
+    reason: 'Use "whom" after a preposition.',
+    id: 'for-whom',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\bwith\s+who\b/i,
+    suggestion: 'with whom',
+    reason: 'Use "whom" after a preposition.',
+    id: 'with-whom',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\bby\s+who\b/i,
+    suggestion: 'by whom',
+    reason: 'Use "whom" after a preposition.',
+    id: 'by-whom',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bcomplement\s+(him|her|them|you|me|us)\b/i,
+    suggestion: (m) => `compliment ${m[1]}`,
+    reason: 'Use "compliment" (praise). "Complement" means to complete.',
+    id: 'complement-compliment',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bthe\s+principle\s+(of\s+the\s+school|said|announced|decided)\b/i,
+    suggestion: (m) => `the principal ${m[1]}`,
+    reason: 'Use "principal" for a school leader. "Principle" is a rule or belief.',
+    id: 'principal-principle',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bweather\s+(or\s+not|we|you|they|he|she|it|I|to)\b/i,
+    suggestion: (m) => `whether ${m[1]}`,
+    reason: 'Use "whether" for conditions/choices. "Weather" refers to climate.',
+    id: 'weather-whether',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bcan't\s+bare\b/i,
+    suggestion: "can't bear",
+    reason: 'Use "bear" (to tolerate). "Bare" means naked or uncovered.',
+    id: 'bare-bear',
+    category: 'spelling',
+  }),
+
+  createRegexRule({
+    pattern: /\bpeek\s+(interest|curiosity)\b/i,
+    suggestion: (m) => `pique ${m[1]}`,
+    reason: 'Use "pique" (to stimulate). "Peek" means to look quickly.',
+    id: 'peek-pique',
+    category: 'spelling',
+  }),
+  createRegexRule({
+    pattern: /\bpeak\s+(interest|curiosity)\b/i,
+    suggestion: (m) => `pique ${m[1]}`,
+    reason: 'Use "pique" (to stimulate). "Peak" means the top.',
+    id: 'peak-pique',
+    category: 'spelling',
+  }),
+
+  // Its vs It
+  createRegexRule({
+    id: 'its-wrong',
+    category: 'spelling',
+    pattern:
+      /\bits\s+(been|become|becoming|seemed|seems|appeared|appears|gotten|made|done|said|written|created)\b/i,
+    suggestion: (m) => `it's ${m[1]}`,
+    reason: "Use 'it's' (contraction) when you mean 'it is' or 'it has'.",
+  }),
+
+  // Their Location
+  createRegexRule({
+    id: 'there-location',
+    category: 'spelling',
+    pattern: /\bover\s+their\b/i,
+    suggestion: 'over there',
+    reason: "Use 'there' for locations, not 'their' (possessive).",
+  }),
+
+  // Your vs You're
+  createRegexRule({
+    id: 'your-should-be-youre',
+    category: 'spelling',
+    pattern:
+      /\byour\s+(welcome|absolutely|right|wrong|amazing|awesome|incredible|fantastic|wonderful|great|excellent|perfect|beautiful|stunning|gorgeous|brilliant|smart|intelligent|talented|skilled|experienced|qualified|prepared|ready|finished|done|complete|correct|incorrect|mistaken|confused|lost|found|gone|here|there|early|late|busy|free|available|unavailable|important|necessary|essential|critical|vital|crucial|key|main|primary|principal|chief|major|minor|significant|relevant|appropriate|suitable|fitting|proper|correct|right|wrong|bad|good|better|best|worse|worst)\b/i,
+    suggestion: (m) => `you're ${m[1]}`,
+    reason: "Use 'you're' (contraction of 'you are') here.",
+  }),
+];

package/src/rules/categories/spelling.ts

@@ -0,0 +1,119 @@
+import { createRegexRule, type Rule } from '../types.js';
+
+const commonMisspellings: Record<string, string> = {
+  teh: 'the',
+  taht: 'that',
+  waht: 'what',
+  whta: 'what',
+  hte: 'the',
+  iwth: 'with',
+  witht: 'with',
+  adn: 'and',
+  nad: 'and',
+  abd: 'bad',
+  becuase: 'because',
+  becasue: 'because',
+  beacuse: 'because',
+  becomeing: 'becoming',
+  begining: 'beginning',
+  believeable: 'believable',
+  buisness: 'business',
+  calender: 'calendar',
+  cant: "can't",
+  collegue: 'colleague',
+  comming: 'coming',
+  completly: 'completely',
+  definately: 'definitely',
+  definitly: 'definitely',
+  dissapear: 'disappear',
+  dissapoint: 'disappoint',
+  embarass: 'embarrass',
+  enviroment: 'environment',
+  existance: 'existence',
+  experiance: 'experience',
+  familar: 'familiar',
+  finaly: 'finally',
+  freind: 'friend',
+  goverment: 'government',
+  governer: 'governor',
+  grammer: 'grammar',
+  happend: 'happened',
+  happenned: 'happened',
+  harrass: 'harass',
+  heighth: 'height',
+  helpfull: 'helpful',
+  immediatly: 'immediately',
+  independant: 'independent',
+  indispensible: 'indispensable',
+  irresistable: 'irresistible',
+  knowlege: 'knowledge',
+  libary: 'library',
+  lisence: 'license',
+  maintainance: 'maintenance',
+  millenium: 'millennium',
+  minature: 'miniature',
+  mischievious: 'mischievous',
+  misspell: 'misspell',
+  neccessary: 'necessary',
+  necessery: 'necessary',
+  noticable: 'noticeable',
+  occassion: 'occasion',
+  occured: 'occurred',
+  occuring: 'occurring',
+  occurence: 'occurrence',
+  parliment: 'parliament',
+  peice: 'piece',
+  persistance: 'persistence',
+  persue: 'pursue',
+  posession: 'possession',
+  potatos: 'potatoes',
+  preceed: 'precede',
+  presance: 'presence',
+  privelege: 'privilege',
+  publically: 'publicly',
+  questionaire: 'questionnaire',
+  realy: 'really',
+  recieve: 'receive',
+  recomend: 'recommend',
+  refered: 'referred',
+  refering: 'referring',
+  relevent: 'relevant',
+  reminisce: 'reminisce',
+  repitition: 'repetition',
+  resistence: 'resistance',
+  seperate: 'separate',
+  similer: 'similar',
+  sincerly: 'sincerely',
+  speach: 'speech',
+  strenght: 'strength',
+  succesful: 'successful',
+  suprise: 'surprise',
+  tendancy: 'tendency',
+  therefor: 'therefore',
+  tommorrow: 'tomorrow',
+  tongue: 'tongue',
+  truely: 'truly',
+  unfortunatly: 'unfortunately',
+  untill: 'until',
+  unusuall: 'unusual',
+  usefull: 'useful',
+  vaccum: 'vacuum',
+  vegatable: 'vegetable',
+  visious: 'vicious',
+  wether: 'whether',
+  wich: 'which',
+  writting: 'writing',
+  yache: 'yacht',
+  yeild: 'yield',
+  yourselfs: 'yourselves',
+};
+
+export const spellingRules: Rule[] = Object.entries(commonMisspellings).map(([wrong, correct]) =>
+  createRegexRule({
+    id: `spell-${wrong}`,
+    category: 'spelling',
+    pattern: new RegExp(`\\b${wrong}\\b`, 'i'),
+    suggestion: correct,
+    reason: `Misspelled word. The correct spelling is "${correct}".`,
+  }),
+);