@f-o-t/content-analysis 1.0.2 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FOT (F-O-T)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,67 +1,39 @@
 {
-   "name": "@f-o-t/content-analysis",
-   "version": "1.0.2",
-   "description": "Content analysis library for SEO, readability, structure, and pattern detection",
-   "type": "module",
-   "private": false,
-   "module": "./dist/index.js",
-   "types": "./dist/index.d.ts",
-   "exports": {
-      ".": {
-         "bun": "./src/index.ts",
-         "import": {
-            "default": "./dist/index.js",
-            "types": "./dist/index.d.ts"
-         },
-         "types": "./dist/index.d.ts"
-      },
-      "./types": {
-         "bun": "./src/types.ts",
-         "import": {
-            "default": "./dist/types.js",
-            "types": "./dist/types.d.ts"
-         },
-         "types": "./dist/types.d.ts"
-      },
-      "./package.json": "./package.json"
-   },
-   "files": [
-      "dist"
-   ],
-   "scripts": {
-      "build": "bunup",
-      "check": "biome check --write .",
-      "dev": "bunup --watch",
-      "test": "bun test",
-      "test:coverage": "bun test --coverage",
-      "test:watch": "bun test --watch",
-      "typecheck": "tsc"
-   },
-   "devDependencies": {
-      "@biomejs/biome": "2.3.12",
-      "@types/bun": "1.3.6",
-      "bumpp": "10.4.0",
-      "bunup": "0.16.20",
-      "typescript": "5.9.3"
-   },
-   "peerDependencies": {
-      "typescript": ">=4.5.0"
-   },
-   "peerDependenciesMeta": {
-      "typescript": {
-         "optional": true
-      }
-   },
-   "license": "MIT",
-   "repository": {
-      "type": "git",
-      "url": "https://github.com/F-O-T/contentta-nx.git"
-   },
-   "homepage": "https://github.com/F-O-T/contentta-nx/blob/master/libraries/content-analysis",
-   "bugs": {
-      "url": "https://github.com/F-O-T/contentta-nx/issues"
-   },
-   "publishConfig": {
-      "access": "public"
-   }
+  "name": "@f-o-t/content-analysis",
+  "version": "1.0.3",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugins/types": {
+      "types": "./dist/plugins/types/index.d.ts",
+      "default": "./dist/plugins/types/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun x --bun fot build",
+    "test": "bun x --bun fot test",
+    "lint": "bun x --bun fot lint",
+    "format": "bun x --bun fot format",
+    "typecheck": "bun x --bun fot typecheck"
+  },
+  "dependencies": {
+    "@f-o-t/markdown": "^1.0.2"
+  },
+  "devDependencies": {
+    "@f-o-t/cli": "^1.0.0",
+    "@f-o-t/config": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/F-O-T/libraries.git",
+    "directory": "libraries/content-analysis"
+  }
 }

package/dist/index.d.ts

@@ -1,241 +0,0 @@
-/**
-* Content Analysis Types
-* All type definitions for SEO, readability, structure, and pattern analysis
-*/
-type SeoIssueType = "title" | "meta_description" | "headings" | "keyword_density" | "content_length" | "readability" | "links" | "images" | "quick_answer" | "first_paragraph" | "heading_keywords" | "structure";
-type Severity = "error" | "warning" | "info";
-type SeoIssue = {
-	type: SeoIssueType;
-	severity: Severity;
-	message: string;
-	suggestion: string;
-};
-type SeoMetrics = {
-	wordCount: number;
-	headingCount: number;
-	paragraphCount: number;
-	linkCount: number;
-	imageCount: number;
-	hasQuickAnswer: boolean;
-	keywordInFirstParagraph: boolean;
-	keywordDensity?: Record<string, number>;
-};
-type SeoResult = {
-	score: number;
-	issues: SeoIssue[];
-	recommendations: string[];
-	metrics: SeoMetrics;
-};
-type SeoInput = {
-	content: string;
-	title?: string;
-	metaDescription?: string;
-	targetKeywords?: string[];
-};
-type TargetAudience = "general" | "technical" | "academic" | "casual";
-type ReadabilityMetrics = {
-	sentenceCount: number;
-	wordCount: number;
-	avgWordsPerSentence: number;
-	avgSyllablesPerWord: number;
-	complexWordCount: number;
-	complexWordPercentage: number;
-};
-type TargetScore = {
-	min: number;
-	max: number;
-	description: string;
-};
-type ReadabilityResult = {
-	fleschKincaidReadingEase: number;
-	fleschKincaidGradeLevel: number;
-	readabilityLevel: string;
-	targetScore: TargetScore;
-	isOnTarget: boolean;
-	suggestions: string[];
-	metrics: ReadabilityMetrics;
-};
-type ContentType = "how-to" | "comparison" | "explainer" | "listicle" | "general";
-type StructureIssue = {
-	type: string;
-	severity: Severity;
-	message: string;
-	suggestion: string;
-};
-type ContentStructure = {
-	hasQuickAnswer: boolean;
-	headingHierarchyValid: boolean;
-	avgParagraphLength: number;
-	hasTableOfContents: boolean;
-	hasTables: boolean;
-	hasConclusion: boolean;
-	headingCount: number;
-	wordCount: number;
-};
-type StructureResult = {
-	score: number;
-	issues: StructureIssue[];
-	structure: ContentStructure;
-};
-type BadPatternType = "word_count_mention" | "word_count_in_title" | "meta_commentary" | "engagement_begging" | "endless_introduction" | "vague_instructions" | "clickbait_markers" | "filler_phrases" | "over_formatting" | "wall_of_text" | "keyword_stuffing";
-type BadPattern = {
-	pattern: string;
-	severity: "error" | "warning";
-	locations: string[];
-	suggestion: string;
-};
-type BadPatternResult = {
-	hasIssues: boolean;
-	issueCount: number;
-	patterns: BadPattern[];
-};
-type KeywordLocationType = "title" | "heading" | "paragraph" | "first100words" | "last100words";
-type KeywordStatus = "optimal" | "low" | "high" | "missing";
-type KeywordLocation = {
-	type: KeywordLocationType;
-	index?: number;
-};
-type KeywordAnalysisItem = {
-	keyword: string;
-	count: number;
-	density: number;
-	locations: KeywordLocation[];
-	status: KeywordStatus;
-	suggestion?: string;
-};
-type TopKeyword = {
-	keyword: string;
-	count: number;
-	density: number;
-};
-type KeywordMetrics = {
-	totalWordCount: number;
-	uniqueWordCount: number;
-	avgKeywordDensity: number;
-};
-type KeywordAnalysisResult = {
-	analysis: KeywordAnalysisItem[];
-	overallScore: number;
-	topKeywords: TopKeyword[];
-	recommendations: string[];
-	metrics: KeywordMetrics;
-};
-type KeywordInput = {
-	content: string;
-	title?: string;
-	targetKeywords: string[];
-};
-type ContentAnalysisResult = {
-	seo: SeoResult;
-	readability: ReadabilityResult;
-	structure: StructureResult;
-	badPatterns: BadPatternResult;
-	keywords: KeywordAnalysisResult | null;
-	analyzedAt: string;
-};
-type AnalysisInput = {
-	content: string;
-	title?: string;
-	description?: string;
-	targetKeywords?: string[];
-};
-/**
-* Analyze content for bad patterns
-*/
-declare function analyzeBadPatterns(content: string, title?: string): BadPatternResult;
-/**
-* Analyze keyword usage in content
-*/
-declare function analyzeKeywords(input: KeywordInput): KeywordAnalysisResult;
-/**
-* Analyze content readability
-*/
-declare function analyzeReadability(content: string, targetAudience?: TargetAudience): ReadabilityResult;
-/**
-* Analyze content for SEO optimization
-*/
-declare function analyzeSeo(input: SeoInput): SeoResult;
-/**
-* Analyze content structure
-*/
-declare function analyzeStructure(content: string, contentType?: ContentType): StructureResult;
-/**
-* Shared utility functions for content analysis
-*/
-/**
-* Count syllables in a word using a simplified vowel group algorithm
-*/
-declare function countSyllables(word: string): number;
-/**
-* Calculate Flesch-Kincaid readability metrics
-*/
-declare function calculateFleschKincaid(text: string): {
-	readingEase: number;
-	gradeLevel: number;
-};
-/**
-* Convert reading ease score to human-readable level
-*/
-declare function getReadabilityLevel(score: number): string;
-/**
-* Find all occurrences of a regex pattern with surrounding context
-*/
-declare function findOccurrences(regex: RegExp, text: string): string[];
-/**
-* Extract words from content
-*/
-declare function extractWords(content: string): string[];
-/**
-* Extract paragraphs from content
-*/
-declare function extractParagraphs(content: string): string[];
-/**
-* Extract headings from markdown content
-*/
-declare function extractHeadings(content: string): Array<{
-	level: number;
-	text: string;
-	index: number;
-}>;
-/**
-* Clamp score between 0 and 100
-*/
-declare function clampScore(score: number): number;
-/**
-* Check if content has a quick answer pattern in the first portion
-*/
-declare function hasQuickAnswerPattern(text: string): boolean;
-/**
-* Check if content has a conclusion section
-*/
-declare function hasConclusionSection(content: string): boolean;
-/**
-* Perform a comprehensive content analysis
-*
-* This function runs all available analyzers and returns a combined result:
-* - SEO analysis (title, meta, keywords, structure)
-* - Readability analysis (Flesch-Kincaid scores)
-* - Structure analysis (headings, paragraphs, quick answers)
-* - Bad pattern detection (filler phrases, clickbait, etc.)
-* - Keyword analysis (density, placement, recommendations)
-*
-* @param input - The content and metadata to analyze
-* @returns Combined analysis results from all analyzers
-*
-* @example
-* ```typescript
-* import { analyzeContent } from '@f-o-t/content-analysis';
-*
-* const result = analyzeContent({
-*   content: '## Introduction\n\nThis is my blog post...',
-*   title: 'My Blog Post Title',
-*   description: 'A short description for SEO',
-*   targetKeywords: ['blog', 'tutorial'],
-* });
-*
-* console.log(result.seo.score); // 85
-* console.log(result.readability.fleschKincaidReadingEase); // 65.2
-* ```
-*/
-declare function analyzeContent(input: AnalysisInput): ContentAnalysisResult;
-export { hasQuickAnswerPattern, hasConclusionSection, getReadabilityLevel, findOccurrences, extractWords, extractParagraphs, extractHeadings, countSyllables, clampScore, calculateFleschKincaid, analyzeStructure, analyzeSeo, analyzeReadability, analyzeKeywords, analyzeContent, analyzeBadPatterns, TopKeyword, TargetScore, TargetAudience, StructureResult, StructureIssue, Severity, SeoResult, SeoMetrics, SeoIssueType, SeoIssue, SeoInput, ReadabilityResult, ReadabilityMetrics, KeywordStatus, KeywordMetrics, KeywordLocationType, KeywordLocation, KeywordInput, KeywordAnalysisResult, KeywordAnalysisItem, ContentType, ContentStructure, ContentAnalysisResult, BadPatternType, BadPatternResult, BadPattern, AnalysisInput };

package/dist/index.js

@@ -1,891 +0,0 @@
-// src/utils.ts
-function countSyllables(word) {
-  const w = word.toLowerCase();
-  if (w.length <= 3)
-    return 1;
-  const vowelGroups = w.match(/[aeiouy]+/g) || [];
-  let count = vowelGroups.length;
-  if (w.endsWith("e"))
-    count--;
-  return Math.max(1, count);
-}
-function calculateFleschKincaid(text) {
-  const cleanText = text.replace(/[^\w\s.!?]/g, "");
-  const sentences = cleanText.split(/[.!?]+/).filter(Boolean);
-  const words = cleanText.split(/\s+/).filter(Boolean);
-  if (words.length === 0 || sentences.length === 0) {
-    return { readingEase: 0, gradeLevel: 0 };
-  }
-  const totalSyllables = words.reduce((sum, word) => sum + countSyllables(word), 0);
-  const avgWordsPerSentence = words.length / sentences.length;
-  const avgSyllablesPerWord = totalSyllables / words.length;
-  const readingEase = 206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord;
-  const gradeLevel = 0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59;
-  return {
-    readingEase: Math.max(0, Math.min(100, Math.round(readingEase * 10) / 10)),
-    gradeLevel: Math.max(0, Math.round(gradeLevel * 10) / 10)
-  };
-}
-function getReadabilityLevel(score) {
-  if (score >= 90)
-    return "Very Easy (5th grade)";
-  if (score >= 80)
-    return "Easy (6th grade)";
-  if (score >= 70)
-    return "Fairly Easy (7th grade)";
-  if (score >= 60)
-    return "Standard (8th-9th grade)";
-  if (score >= 50)
-    return "Fairly Difficult (10th-12th grade)";
-  if (score >= 30)
-    return "Difficult (College)";
-  return "Very Difficult (College Graduate)";
-}
-function findOccurrences(regex, text) {
-  const matches = [];
-  const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
-  const globalRegex = new RegExp(regex.source, flags);
-  let match;
-  while ((match = globalRegex.exec(text)) !== null) {
-    const start = Math.max(0, match.index - 20);
-    const end = Math.min(text.length, match.index + match[0].length + 20);
-    const context = text.slice(start, end);
-    matches.push(`...${context}...`);
-  }
-  return matches;
-}
-function extractWords(content) {
-  return content.split(/\s+/).filter(Boolean);
-}
-function extractParagraphs(content) {
-  return content.split(/\n\n+/).filter(Boolean);
-}
-function extractHeadings(content) {
-  const headingMatches = [...content.matchAll(/^(#{1,6})\s+(.+)$/gm)];
-  const headings = [];
-  for (const match of headingMatches) {
-    const hashMarks = match[1];
-    const headingText = match[2];
-    if (hashMarks && headingText) {
-      headings.push({
-        level: hashMarks.length,
-        text: headingText,
-        index: match.index ?? 0
-      });
-    }
-  }
-  return headings;
-}
-function clampScore(score) {
-  return Math.max(0, Math.min(100, score));
-}
-function hasQuickAnswerPattern(text) {
-  return /\*\*quick\s*answer\*\*|>.*quick.*answer|tl;?dr|em\s+resumo|resumindo/i.test(text) || /^.*?\*\*[^*]+\*\*\s+(?:é|is|are|was|were|significa)\s/im.test(text) || /^\|.*\|.*\|$/m.test(text);
-}
-function hasConclusionSection(content) {
-  return /##\s*(?:conclus|conclusion|resumo|takeaway|key\s*takeaway|final|wrapping\s*up)/i.test(content);
-}
-
-// src/bad-patterns.ts
-function analyzeBadPatterns(content, title) {
-  const patterns = [];
-  const wordCountPattern = /\b\d+\+?\s*(?:palavras?|words?)\b|~\s*\d+\s*(?:palavras?|words?)|word\s*count|contagem\s*de\s*palavras/gi;
-  const wordCountMatches = findOccurrences(wordCountPattern, content);
-  if (wordCountMatches.length > 0) {
-    patterns.push({
-      pattern: "word_count_mention",
-      severity: "warning",
-      locations: wordCountMatches,
-      suggestion: "Remove word count mentions. Readers don't care about article length."
-    });
-  }
-  if (title) {
-    wordCountPattern.lastIndex = 0;
-    const titleWordCountMatch = wordCountPattern.exec(title);
-    if (titleWordCountMatch) {
-      patterns.push({
-        pattern: "word_count_in_title",
-        severity: "warning",
-        locations: [`Title: "${title}"`],
-        suggestion: "Remove word count claims from title. Focus on value, not length."
-      });
-    }
-  }
-  const metaCommentaryPatterns = [
-    /\b(?:neste\s+artigo|in\s+this\s+(?:article|post|guide))\b/gi,
-    /\b(?:como\s+mencionado|as\s+(?:mentioned|discussed|noted)\s+(?:above|earlier|before))\b/gi,
-    /\b(?:vamos\s+explorar|let'?s\s+explore|we\s+will\s+(?:discuss|explore|cover))\b/gi,
-    /\b(?:conforme\s+vimos|as\s+we\s+(?:saw|discussed|covered))\b/gi
-  ];
-  for (const pattern of metaCommentaryPatterns) {
-    const matches = findOccurrences(pattern, content);
-    if (matches.length > 0) {
-      patterns.push({
-        pattern: "meta_commentary",
-        severity: "warning",
-        locations: matches,
-        suggestion: "Remove meta-commentary. Just deliver the information directly."
-      });
-    }
-  }
-  const engagementPatterns = [
-    /\b(?:não\s+esqueça\s+de|don'?t\s+forget\s+to)\s+(?:curtir|like|subscribe|seguir|compartilhar|share)/gi,
-    /\b(?:deixe\s+(?:um\s+)?comentário|leave\s+a\s+comment|comment\s+below)/gi,
-    /\b(?:inscreva-se|subscribe|sign\s+up)\s+(?:para|to|for)\s+(?:nossa|my|our|the)\s+(?:newsletter|canal|channel)/gi,
-    /\b(?:compartilhe\s+com|share\s+(?:this|with))\s+(?:seus\s+amigos|your\s+friends)/gi,
-    /\bsmash\s+(?:that\s+)?(?:like|subscribe)\s+button\b/gi
-  ];
-  for (const pattern of engagementPatterns) {
-    const matches = findOccurrences(pattern, content);
-    if (matches.length > 0) {
-      patterns.push({
-        pattern: "engagement_begging",
-        severity: "warning",
-        locations: matches,
-        suggestion: "Remove engagement begging. Let quality content earn engagement naturally."
-      });
-    }
-  }
-  const firstH2Index = content.search(/^##\s+/m);
-  if (firstH2Index > 0) {
-    const introText = content.slice(0, firstH2Index);
-    const introWords = extractWords(introText).length;
-    if (introWords > 150) {
-      patterns.push({
-        pattern: "endless_introduction",
-        severity: "warning",
-        locations: [`Introduction: ~${introWords} words before first H2`],
-        suggestion: "Shorten introduction to under 150 words. Get to the point faster."
-      });
-    }
-  }
-  const vaguePatterns = [
-    /\b(?:configure\s+(?:appropriately|properly|correctly))\b/gi,
-    /\b(?:set\s+up\s+(?:as\s+needed|accordingly))\b/gi,
-    /\b(?:adjust\s+(?:as\s+necessary|accordingly|as\s+needed))\b/gi,
-    /\b(?:use\s+(?:the\s+right|appropriate|suitable)\s+(?:settings|options|values))\b/gi
-  ];
-  for (const pattern of vaguePatterns) {
-    const matches = findOccurrences(pattern, content);
-    if (matches.length > 0) {
-      patterns.push({
-        pattern: "vague_instructions",
-        severity: "warning",
-        locations: matches,
-        suggestion: "Be specific. Instead of 'configure appropriately', say exactly what to configure and how."
-      });
-    }
-  }
-  const clickbaitPatterns = [
-    /\b(?:you\s+won'?t\s+believe|você\s+não\s+vai\s+acreditar)\b/gi,
-    /\b(?:this\s+one\s+(?:trick|tip|secret))\b/gi,
-    /\b(?:AMAZING|INCREDIBLE|MIND-?BLOWING)\b/g,
-    /!!+|\?!+|!{3,}/g
-  ];
-  for (const pattern of clickbaitPatterns) {
-    const matches = findOccurrences(pattern, content);
-    if (matches.length > 0) {
-      patterns.push({
-        pattern: "clickbait_markers",
-        severity: "warning",
-        locations: matches,
-        suggestion: "Remove clickbait language. Use accurate, professional language instead."
-      });
-    }
-  }
-  const fillerPatterns = [
-    /\b(?:it\s+goes\s+without\s+saying|vai\s+sem\s+dizer)\b/gi,
-    /\b(?:without\s+further\s+ado|sem\s+mais\s+delongas)\b/gi,
-    /\b(?:at\s+the\s+end\s+of\s+the\s+day|no\s+final\s+das\s+contas)\b/gi,
-    /\b(?:in\s+today'?s\s+(?:digital\s+)?(?:landscape|world|age))\b/gi,
-    /\b(?:(?:as\s+)?a\s+matter\s+of\s+fact)\b/gi,
-    /\b(?:needless\s+to\s+say|escusado\s+será\s+dizer)\b/gi,
-    /\b(?:in\s+(?:conclusion|summary)|em\s+(?:conclusão|resumo))(?:\s*[,:])\b/gi
-  ];
-  for (const pattern of fillerPatterns) {
-    const matches = findOccurrences(pattern, content);
-    if (matches.length > 0) {
-      patterns.push({
-        pattern: "filler_phrases",
-        severity: "warning",
-        locations: matches,
-        suggestion: "Remove filler phrases. They add no value and waste reader's time."
-      });
-    }
-  }
-  const overFormattingPattern = /(\*{1,2}[^*]+\*{1,2}\s*){3,}|(_{1,2}[^_]+_{1,2}\s*){3,}/g;
-  const overFormattingMatches = findOccurrences(overFormattingPattern, content);
-  if (overFormattingMatches.length > 0) {
-    patterns.push({
-      pattern: "over_formatting",
-      severity: "warning",
-      locations: overFormattingMatches,
-      suggestion: "Reduce consecutive formatting. Use bold/italic sparingly for emphasis."
-    });
-  }
-  const paragraphs = extractParagraphs(content);
-  const longParagraphs = [];
-  for (const paragraph of paragraphs) {
-    if (paragraph.startsWith("```") || paragraph.startsWith("#"))
-      continue;
-    const wordCount = extractWords(paragraph).length;
-    if (wordCount > 100) {
-      const preview = paragraph.slice(0, 50) + "..." + paragraph.slice(-30);
-      longParagraphs.push(`~${wordCount} words: "${preview}"`);
-    }
-  }
-  if (longParagraphs.length > 0) {
-    patterns.push({
-      pattern: "wall_of_text",
-      severity: "warning",
-      locations: longParagraphs,
-      suggestion: "Break up long paragraphs. Keep paragraphs under 100 words for better readability."
-    });
-  }
-  const wordsLower = content.toLowerCase();
-  const totalWords = extractWords(content).length;
-  const phraseCount = {};
-  const tokens = wordsLower.match(/\b[a-záàâãéèêíïóôõöúç]{3,}\b/g) || [];
-  for (let i = 0;i < tokens.length - 1; i++) {
-    const bigram = `${tokens[i]} ${tokens[i + 1]}`;
-    phraseCount[bigram] = (phraseCount[bigram] || 0) + 1;
-  }
-  const stuffedPhrases = [];
-  for (const [phrase, count] of Object.entries(phraseCount)) {
-    const density = count / totalWords * 100;
-    if (density > 3 && count > 5) {
-      stuffedPhrases.push(`"${phrase}" appears ${count} times (${density.toFixed(1)}% density)`);
-    }
-  }
-  if (stuffedPhrases.length > 0) {
-    patterns.push({
-      pattern: "keyword_stuffing",
-      severity: "warning",
-      locations: stuffedPhrases,
-      suggestion: "Reduce keyword repetition. Use synonyms and natural language variation."
-    });
-  }
-  return {
-    hasIssues: patterns.length > 0,
-    issueCount: patterns.length,
-    patterns
-  };
-}
-// src/keywords.ts
-function analyzeKeywords(input) {
-  const { content, title, targetKeywords } = input;
-  const analysis = [];
-  const recommendations = [];
-  const words = extractWords(content);
-  const totalWordCount = words.length;
-  const uniqueWords = new Set(words.map((w) => w.toLowerCase()));
-  const contentLower = content.toLowerCase();
-  const titleLower = title?.toLowerCase() || "";
-  const headings = content.match(/^#{2,6}\s+(.+)$/gm) || [];
-  const headingsText = headings.join(" ").toLowerCase();
-  const first100Words = words.slice(0, 100).join(" ").toLowerCase();
-  const last100Words = words.slice(-100).join(" ").toLowerCase();
-  let totalDensity = 0;
-  for (const keyword of targetKeywords) {
-    const keywordLower = keyword.toLowerCase();
-    const regex = new RegExp(keywordLower, "gi");
-    const matches = contentLower.match(regex) || [];
-    const count = matches.length;
-    const density = totalWordCount > 0 ? count / totalWordCount * 100 : 0;
-    totalDensity += density;
-    const locations = [];
-    if (titleLower.includes(keywordLower)) {
-      locations.push({ type: "title" });
-    }
-    if (headingsText.includes(keywordLower)) {
-      locations.push({ type: "heading" });
-    }
-    if (first100Words.includes(keywordLower)) {
-      locations.push({ type: "first100words" });
-    }
-    if (last100Words.includes(keywordLower)) {
-      locations.push({ type: "last100words" });
-    }
-    let status;
-    let suggestion;
-    if (count === 0) {
-      status = "missing";
-      suggestion = `Add "${keyword}" naturally to your content`;
-    } else if (density < 0.5) {
-      status = "low";
-      suggestion = `Consider using "${keyword}" a few more times`;
-    } else if (density > 3) {
-      status = "high";
-      suggestion = `Reduce usage of "${keyword}" - it may appear spammy`;
-    } else {
-      status = "optimal";
-    }
-    analysis.push({
-      keyword,
-      count,
-      density: Math.round(density * 100) / 100,
-      locations,
-      status,
-      suggestion
-    });
-  }
-  let overallScore = 100;
-  for (const item of analysis) {
-    if (item.status === "missing")
-      overallScore -= 15;
-    else if (item.status === "low")
-      overallScore -= 10;
-    else if (item.status === "high")
-      overallScore -= 5;
-  }
-  overallScore = Math.max(0, Math.min(100, overallScore));
-  const missingKeywords = analysis.filter((a) => a.status === "missing");
-  const lowKeywords = analysis.filter((a) => a.status === "low");
-  const highKeywords = analysis.filter((a) => a.status === "high");
-  if (missingKeywords.length > 0) {
-    recommendations.push(`Add missing keywords: ${missingKeywords.map((k) => k.keyword).join(", ")}`);
-  }
-  if (lowKeywords.length > 0) {
-    recommendations.push(`Increase usage of: ${lowKeywords.map((k) => k.keyword).join(", ")}`);
-  }
-  if (highKeywords.length > 0) {
-    recommendations.push(`Reduce overused keywords: ${highKeywords.map((k) => k.keyword).join(", ")}`);
-  }
-  const phraseCount = {};
-  const tokens = contentLower.match(/\b[a-záàâãéèêíïóôõöúç]{3,}\b/g) || [];
-  for (const token of tokens) {
-    phraseCount[token] = (phraseCount[token] || 0) + 1;
-  }
-  const topKeywords = Object.entries(phraseCount).filter(([word]) => word.length > 4 && !["that", "this", "with", "from", "have", "been"].includes(word)).sort(([, a], [, b]) => b - a).slice(0, 10).map(([keyword, count]) => ({
-    keyword,
-    count,
-    density: Math.round(count / totalWordCount * 1e4) / 100
-  }));
-  const metrics = {
-    totalWordCount,
-    uniqueWordCount: uniqueWords.size,
-    avgKeywordDensity: targetKeywords.length > 0 ? Math.round(totalDensity / targetKeywords.length * 100) / 100 : 0
-  };
-  return {
-    analysis,
-    overallScore,
-    topKeywords,
-    recommendations,
-    metrics
-  };
-}
-// src/readability.ts
-var TARGET_SCORES = {
-  general: {
-    min: 60,
-    max: 70,
-    description: "Easy to read for general audience"
-  },
-  technical: {
-    min: 40,
-    max: 60,
-    description: "Technical but accessible"
-  },
-  academic: {
-    min: 30,
-    max: 50,
-    description: "Academic/professional level"
-  },
-  casual: {
-    min: 70,
-    max: 80,
-    description: "Very easy, conversational"
-  }
-};
-function analyzeReadability(content, targetAudience = "general") {
-  const { readingEase, gradeLevel } = calculateFleschKincaid(content);
-  const readabilityLevel = getReadabilityLevel(readingEase);
-  const targetScore = TARGET_SCORES[targetAudience];
-  const isOnTarget = readingEase >= targetScore.min && readingEase <= targetScore.max;
-  const cleanText = content.replace(/[^\w\s.!?]/g, "");
-  const sentences = cleanText.split(/[.!?]+/).filter(Boolean);
-  const words = cleanText.split(/\s+/).filter(Boolean);
-  const complexWords = words.filter((w) => countSyllables(w) >= 3);
-  const totalSyllables = words.reduce((sum, word) => sum + countSyllables(word), 0);
-  const suggestions = [];
-  if (readingEase < targetScore.min) {
-    suggestions.push("Simplify your language - use shorter words and sentences");
-    const avgWordsPerSentence = words.length / sentences.length;
-    if (avgWordsPerSentence > 20) {
-      suggestions.push(`Average sentence length is ${Math.round(avgWordsPerSentence)} words. Try to keep it under 20.`);
-    }
-    if (complexWords.length / words.length > 0.2) {
-      suggestions.push("Too many complex words (3+ syllables). Replace with simpler alternatives.");
-    }
-    suggestions.push("Break long sentences into shorter ones");
-    suggestions.push("Use active voice instead of passive voice");
-  } else if (readingEase > targetScore.max && targetAudience !== "casual") {
-    suggestions.push("Content may be too simple for your target audience");
-    suggestions.push("Consider adding more technical depth or detail");
-  }
-  if (sentences.some((s) => s.split(/\s+/).length > 40)) {
-    suggestions.push("Some sentences are very long. Consider breaking them up.");
-  }
-  const metrics = {
-    sentenceCount: sentences.length,
-    wordCount: words.length,
-    avgWordsPerSentence: sentences.length > 0 ? Math.round(words.length / sentences.length * 10) / 10 : 0,
-    avgSyllablesPerWord: words.length > 0 ? Math.round(totalSyllables / words.length * 100) / 100 : 0,
-    complexWordCount: complexWords.length,
-    complexWordPercentage: words.length > 0 ? Math.round(complexWords.length / words.length * 1000) / 10 : 0
-  };
-  return {
-    fleschKincaidReadingEase: readingEase,
-    fleschKincaidGradeLevel: gradeLevel,
-    readabilityLevel,
-    targetScore,
-    isOnTarget,
-    suggestions,
-    metrics
-  };
-}
-// src/seo.ts
-function analyzeSeo(input) {
-  const { content, title, metaDescription, targetKeywords } = input;
-  const issues = [];
-  const recommendations = [];
-  const words = extractWords(content);
-  const wordCount = words.length;
-  const paragraphs = extractParagraphs(content);
-  const headings = content.match(/^#{1,6}\s.+$/gm) || [];
-  const h2Headings = content.match(/^##\s.+$/gm) || [];
-  const links = content.match(/\[.+?\]\(.+?\)/g) || [];
-  const images = content.match(/!\[.+?\]\(.+?\)/g) || [];
-  const firstH2Index = content.search(/^##\s/m);
-  const firstParagraphText = firstH2Index > 0 ? content.slice(0, firstH2Index) : words.slice(0, 100).join(" ");
-  let score = 100;
-  if (!title) {
-    issues.push({
-      type: "title",
-      severity: "error",
-      message: "Missing title",
-      suggestion: "Add a descriptive title (50-60 characters)"
-    });
-    score -= 15;
-  } else if (title.length < 30) {
-    issues.push({
-      type: "title",
-      severity: "warning",
-      message: "Title is too short",
-      suggestion: "Expand title to 50-60 characters for better SEO"
-    });
-    score -= 8;
-  } else if (title.length > 60) {
-    issues.push({
-      type: "title",
-      severity: "warning",
-      message: "Title is too long",
-      suggestion: "Shorten to under 60 characters to avoid truncation in search results"
-    });
-    score -= 5;
-  }
-  if (title && targetKeywords && targetKeywords.length > 0) {
-    const titleLower = title.toLowerCase();
-    const hasKeywordInTitle = targetKeywords.some((kw) => titleLower.includes(kw.toLowerCase()));
-    if (!hasKeywordInTitle) {
-      issues.push({
-        type: "title",
-        severity: "warning",
-        message: "Primary keyword not found in title",
-        suggestion: "Include your primary keyword naturally in the title"
-      });
-      score -= 5;
-    }
-  }
-  if (!metaDescription) {
-    issues.push({
-      type: "meta_description",
-      severity: "warning",
-      message: "Missing meta description",
-      suggestion: "Add a meta description (150-160 characters)"
-    });
-    score -= 10;
-  } else if (metaDescription.length < 120) {
-    issues.push({
-      type: "meta_description",
-      severity: "info",
-      message: "Meta description could be longer",
-      suggestion: "Expand to 150-160 characters"
-    });
-    score -= 3;
-  } else if (metaDescription.length > 160) {
-    issues.push({
-      type: "meta_description",
-      severity: "warning",
-      message: "Meta description is too long",
-      suggestion: "Shorten to under 160 characters"
-    });
-    score -= 5;
-  }
-  if (headings.length === 0) {
-    issues.push({
-      type: "headings",
-      severity: "error",
-      message: "No headings found",
-      suggestion: "Add H2 and H3 headings to structure your content"
-    });
-    score -= 15;
-  } else if (h2Headings.length < 3 && wordCount > 500) {
-    issues.push({
-      type: "headings",
-      severity: "warning",
-      message: "Too few H2 headings for content length",
-      suggestion: "Add more H2 subheadings (one every 200-300 words)"
-    });
-    score -= 5;
-  }
-  const h1Headings = content.match(/^#\s.+$/gm) || [];
-  if (h1Headings.length > 0) {
-    issues.push({
-      type: "headings",
-      severity: "error",
-      message: "H1 heading found in content body",
-      suggestion: "Remove H1 from content. The title is in frontmatter. Start with H2."
-    });
-    score -= 10;
-  }
-  if (targetKeywords && targetKeywords.length > 0 && h2Headings.length > 0) {
-    const h2Text = h2Headings.join(" ").toLowerCase();
-    const hasKeywordInH2 = targetKeywords.some((kw) => h2Text.includes(kw.toLowerCase()));
-    if (!hasKeywordInH2) {
-      issues.push({
-        type: "heading_keywords",
-        severity: "info",
-        message: "Target keywords not found in any H2 headings",
-        suggestion: "Include keywords naturally in at least one H2 heading"
-      });
-      score -= 3;
-    }
-  }
-  if (wordCount < 300) {
-    issues.push({
-      type: "content_length",
-      severity: "error",
-      message: "Content is too short",
-      suggestion: "Aim for at least 600-1000 words for blog posts"
-    });
-    score -= 10;
-  } else if (wordCount < 600) {
-    issues.push({
-      type: "content_length",
-      severity: "warning",
-      message: "Content could be longer",
-      suggestion: "Consider expanding to 1000+ words for better ranking"
-    });
-    score -= 5;
-  }
-  if (links.length === 0 && wordCount > 500) {
-    issues.push({
-      type: "links",
-      severity: "warning",
-      message: "No links found",
-      suggestion: "Add internal and external links to improve SEO"
-    });
-    score -= 10;
-  } else if (links.length < 3 && wordCount > 1000) {
-    issues.push({
-      type: "links",
-      severity: "info",
-      message: "Few links for content length",
-      suggestion: "Add more internal links to related content and external links to authoritative sources"
-    });
-    score -= 3;
-  }
-  if (images.length === 0 && wordCount > 300) {
-    issues.push({
-      type: "images",
-      severity: "info",
-      message: "No images found",
-      suggestion: "Add images with descriptive alt text"
-    });
-    score -= 3;
-  }
-  const hasQuickAnswer = hasQuickAnswerPattern(firstParagraphText);
-  if (!hasQuickAnswer && wordCount > 300) {
-    issues.push({
-      type: "quick_answer",
-      severity: "warning",
-      message: "No quick answer detected in first 100 words",
-      suggestion: "Add a TL;DR, definition lead, or comparison table early to answer the reader's question immediately"
-    });
-    score -= 10;
-  }
-  let keywordInFirstParagraph = false;
-  if (targetKeywords && targetKeywords.length > 0) {
-    const firstParaLower = firstParagraphText.toLowerCase();
-    keywordInFirstParagraph = targetKeywords.some((kw) => firstParaLower.includes(kw.toLowerCase()));
-    if (!keywordInFirstParagraph) {
-      issues.push({
-        type: "first_paragraph",
-        severity: "warning",
-        message: "Primary keyword not found in first paragraph",
-        suggestion: "Include your primary keyword in the first 100 words for better SEO"
-      });
-      score -= 5;
-    }
-  }
-  const keywordDensity = {};
-  if (targetKeywords && targetKeywords.length > 0) {
-    const contentLower = content.toLowerCase();
-    for (const keyword of targetKeywords) {
-      const regex = new RegExp(keyword.toLowerCase(), "gi");
-      const matches = contentLower.match(regex) || [];
-      keywordDensity[keyword] = Number((matches.length / wordCount * 100).toFixed(2));
-      if (keywordDensity[keyword] === 0) {
-        issues.push({
-          type: "keyword_density",
-          severity: "warning",
-          message: `Target keyword "${keyword}" not found`,
-          suggestion: `Include "${keyword}" naturally in your content`
-        });
-        score -= 5;
-      } else if (keywordDensity[keyword] > 3) {
-        issues.push({
-          type: "keyword_density",
-          severity: "warning",
-          message: `Keyword "${keyword}" may be overused (${keywordDensity[keyword]}%)`,
-          suggestion: "Reduce keyword density to 1-2%"
-        });
-        score -= 3;
-      }
-    }
-  }
-  const hasConclusion = hasConclusionSection(content);
-  if (!hasConclusion && wordCount > 500) {
-    issues.push({
-      type: "structure",
-      severity: "info",
-      message: "No conclusion section detected",
-      suggestion: "Add a conclusion with key takeaways and a call-to-action"
-    });
-    score -= 5;
-  }
-  if (issues.some((i) => i.type === "content_length")) {
-    recommendations.push("Expand your content with more detailed explanations and examples");
-  }
-  if (issues.some((i) => i.type === "headings")) {
-    recommendations.push("Structure your content with clear H2 and H3 headings");
-  }
-  if (issues.some((i) => i.type === "links")) {
-    recommendations.push("Add relevant internal links to other blog posts and external links to authoritative sources");
-  }
-  if (issues.some((i) => i.type === "quick_answer")) {
-    recommendations.push("Start with a quick answer - readers want the answer immediately, not after scrolling");
-  }
-  if (issues.some((i) => i.type === "first_paragraph")) {
-    recommendations.push("Include your primary keyword in the first paragraph for better search visibility");
-  }
-  const metrics = {
-    wordCount,
-    headingCount: headings.length,
-    paragraphCount: paragraphs.length,
-    linkCount: links.length,
-    imageCount: images.length,
-    hasQuickAnswer,
-    keywordInFirstParagraph,
-    keywordDensity: Object.keys(keywordDensity).length > 0 ? keywordDensity : undefined
-  };
-  return {
-    score: clampScore(score),
-    issues,
-    recommendations,
-    metrics
-  };
-}
-// src/structure.ts
-function analyzeStructure(content, contentType) {
-  const issues = [];
-  let score = 100;
-  const words = extractWords(content);
-  const wordCount = words.length;
-  const paragraphs = extractParagraphs(content);
-  const headings = extractHeadings(content);
-  const hasH1InContent = headings.some((h) => h.level === 1);
-  if (hasH1InContent) {
-    issues.push({
-      type: "heading_h1",
-      severity: "error",
-      message: "H1 heading found in content body",
-      suggestion: "Remove H1 (# heading) from content. The title is in frontmatter. Start content with H2 (##)."
-    });
-    score -= 15;
-  }
-  let headingHierarchyValid = true;
-  for (let i = 1;i < headings.length; i++) {
-    const prevHeading = headings[i - 1];
-    const currentHeading = headings[i];
-    if (!prevHeading || !currentHeading)
-      continue;
-    const prevLevel = prevHeading.level;
-    const currentLevel = currentHeading.level;
-    if (currentLevel > prevLevel + 1) {
-      headingHierarchyValid = false;
-      issues.push({
-        type: "heading_hierarchy",
-        severity: "warning",
-        message: `Heading level skipped: H${prevLevel} to H${currentLevel} ("${currentHeading.text}")`,
-        suggestion: `Don't skip heading levels. Use H${prevLevel + 1} instead of H${currentLevel}.`
-      });
-      score -= 5;
-    }
-  }
-  const first100Words = words.slice(0, 100).join(" ");
-  const hasQuickAnswer = hasQuickAnswerPattern(first100Words);
-  if (!hasQuickAnswer && wordCount > 300) {
-    issues.push({
-      type: "quick_answer",
-      severity: "warning",
-      message: "No quick answer detected in first 100 words",
-      suggestion: "Add a TL;DR box, definition lead, or comparison table early to answer the reader's question immediately."
-    });
-    score -= 10;
-  }
-  let totalSentences = 0;
-  let longParagraphs = 0;
-  for (const paragraph of paragraphs) {
-    if (paragraph.startsWith("#") || paragraph.startsWith("```"))
-      continue;
-    const sentences = paragraph.split(/[.!?]+/).filter(Boolean);
-    totalSentences += sentences.length;
-    if (sentences.length > 4) {
-      longParagraphs++;
-    }
-  }
-  const avgParagraphLength = paragraphs.length > 0 ? totalSentences / paragraphs.length : 0;
-  if (longParagraphs > 0) {
-    issues.push({
-      type: "paragraph_length",
-      severity: "info",
-      message: `${longParagraphs} paragraph(s) exceed 4 sentences`,
-      suggestion: "Break up long paragraphs. Aim for 2-4 sentences per paragraph for better readability."
-    });
-    score -= Math.min(longParagraphs * 2, 10);
-  }
-  const h2Headings = headings.filter((h) => h.level === 2);
-  const expectedH2Count = Math.floor(wordCount / 250);
-  if (h2Headings.length < expectedH2Count && wordCount > 500) {
-    issues.push({
-      type: "heading_frequency",
-      severity: "warning",
-      message: `Only ${h2Headings.length} H2 headings for ${wordCount} words (recommended: ${expectedH2Count})`,
-      suggestion: "Add more H2 headings to break up content. Aim for one H2 every 200-300 words."
-    });
-    score -= 5;
-  }
-  const hasTableOfContents = /##\s*(?:table of contents|sumário|índice|contents)/i.test(content) || /\[.*\]\(#.*\)/.test(content.slice(0, 500));
-  if (wordCount > 1500 && !hasTableOfContents) {
-    issues.push({
-      type: "table_of_contents",
-      severity: "info",
-      message: "No table of contents detected for long-form content",
-      suggestion: "Add a table of contents near the beginning for posts over 1500 words."
-    });
-    score -= 3;
-  }
-  const hasTables = /^\|.*\|.*\|$/m.test(content);
-  const hasConclusion = hasConclusionSection(content);
-  if (!hasConclusion && wordCount > 500) {
-    issues.push({
-      type: "conclusion",
-      severity: "info",
-      message: "No conclusion section detected",
-      suggestion: "Add a conclusion with key takeaways and a call-to-action."
-    });
-    score -= 5;
-  }
-  if (contentType === "how-to") {
-    const hasNumberedSteps = /^\d+\.\s+/m.test(content) || /step\s*\d+|passo\s*\d+/i.test(content);
-    if (!hasNumberedSteps) {
-      issues.push({
-        type: "how_to_structure",
-        severity: "warning",
-        message: "How-to content should have numbered steps",
-        suggestion: "Use numbered lists (1. 2. 3.) for step-by-step instructions."
-      });
-      score -= 5;
-    }
-  }
-  if (contentType === "comparison") {
-    if (!hasTables) {
-      issues.push({
-        type: "comparison_structure",
-        severity: "warning",
-        message: "Comparison content should include a comparison table",
-        suggestion: "Add a table comparing key metrics between the options."
-      });
-      score -= 5;
-    }
-  }
-  if (contentType === "listicle") {
-    const listItemCount = (content.match(/^[-*]\s+/gm) || []).length;
-    if (listItemCount < 3) {
-      issues.push({
-        type: "listicle_structure",
-        severity: "warning",
-        message: "Listicle should have multiple list items",
-        suggestion: "Add more items to your list for a comprehensive listicle."
-      });
-      score -= 5;
-    }
-  }
-  const structure = {
-    hasQuickAnswer,
-    headingHierarchyValid,
-    avgParagraphLength: Math.round(avgParagraphLength * 10) / 10,
-    hasTableOfContents,
-    hasTables,
-    hasConclusion,
-    headingCount: headings.length,
-    wordCount
-  };
-  return {
-    score: clampScore(score),
-    issues,
-    structure
-  };
-}
-// src/index.ts
-function analyzeContent(input) {
-  const { content, title, description, targetKeywords } = input;
-  const seo = analyzeSeo({
-    content,
-    title,
-    metaDescription: description,
-    targetKeywords
-  });
-  const readability = analyzeReadability(content, "general");
-  const structure = analyzeStructure(content);
-  const badPatterns = analyzeBadPatterns(content, title);
-  const keywords = targetKeywords && targetKeywords.length > 0 ? analyzeKeywords({ content, title, targetKeywords }) : null;
-  return {
-    seo,
-    readability,
-    structure,
-    badPatterns,
-    keywords,
-    analyzedAt: new Date().toISOString()
-  };
-}
-export {
-  hasQuickAnswerPattern,
-  hasConclusionSection,
-  getReadabilityLevel,
-  findOccurrences,
-  extractWords,
-  extractParagraphs,
-  extractHeadings,
-  countSyllables,
-  clampScore,
-  calculateFleschKincaid,
-  analyzeStructure,
-  analyzeSeo,
-  analyzeReadability,
-  analyzeKeywords,
-  analyzeContent,
-  analyzeBadPatterns
-};