Word Counter Guide: Count Words, Characters, and Reading Time Accurately

function countWords(text) {
  // Remove extra whitespace and split by spaces
  const words = text.trim().split(/\s+/);

  // Filter out empty strings
  return words.filter(word => word.length > 0).length;
}

function countCharacters(text, includeSpaces = true) {
  if (includeSpaces) {
    return text.length;
  }
  // Remove all whitespace
  return text.replace(/\s/g, '').length;
}

function countSentences(text) {
  // Split by sentence-ending punctuation
  const sentences = text.split(/[.!?]+/);
  return sentences.filter(s => s.trim().length > 0).length;
}

function countParagraphs(text) {
  // Split by double line breaks
  const paragraphs = text.split(/\n\n+/);
  return paragraphs.filter(p => p.trim().length > 0).length;
}

// Usage
const text = "Hello world! This is a test. How are you?";
console.log('Words:', countWords(text));           // 9
console.log('Characters:', countCharacters(text)); // 42
console.log('Sentences:', countSentences(text));   // 3

class TextAnalyzer {
  constructor(text) {
    this.text = text;
    this.cleanText = this.clean(text);
  }

  clean(text) {
    // Remove URLs
    text = text.replace(/https?:\/\/\S+/gi, '');
    // Remove email addresses
    text = text.replace(/\S+@\S+\.\S+/g, '');
    // Normalize whitespace
    return text.trim().replace(/\s+/g, ' ');
  }

  wordCount() {
    if (!this.cleanText) return 0;
    return this.cleanText.split(/\s+/).filter(w => w.length > 0).length;
  }

  characterCount(includeSpaces = true) {
    return includeSpaces
      ? this.text.length
      : this.text.replace(/\s/g, '').length;
  }

  sentenceCount() {
    const sentences = this.cleanText.split(/[.!?]+/);
    return sentences.filter(s => s.trim().length > 0).length;
  }

  paragraphCount() {
    const paragraphs = this.text.split(/\n\n+/);
    return paragraphs.filter(p => p.trim().length > 0).length;
  }

  averageWordLength() {
    const words = this.cleanText.split(/\s+/);
    const totalLength = words.reduce((sum, word) => sum + word.length, 0);
    return (totalLength / words.length).toFixed(2);
  }

  averageWordsPerSentence() {
    const words = this.wordCount();
    const sentences = this.sentenceCount();
    return (words / sentences).toFixed(2);
  }

  longestWord() {
    const words = this.cleanText.split(/\s+/);
    return words.reduce((longest, word) =>
      word.length > longest.length ? word : longest
    , '');
  }

  getAllStats() {
    return {
      words: this.wordCount(),
      characters: this.characterCount(true),
      charactersNoSpaces: this.characterCount(false),
      sentences: this.sentenceCount(),
      paragraphs: this.paragraphCount(),
      averageWordLength: this.averageWordLength(),
      averageWordsPerSentence: this.averageWordsPerSentence(),
      longestWord: this.longestWord()
    };
  }
}

// Usage
const analyzer = new TextAnalyzer(`
  This is a sample text for analysis.
  It has multiple sentences and paragraphs.

  This is the second paragraph with more content to analyze.
`);

console.log(analyzer.getAllStats());

import React, { useState, useMemo } from 'react';

function WordCounter() {
  const [text, setText] = useState('');

  const stats = useMemo(() => {
    const words = text.trim().split(/\s+/).filter(w => w.length > 0).length;
    const chars = text.length;
    const charsNoSpaces = text.replace(/\s/g, '').length;
    const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 0).length;
    const paragraphs = text.split(/\n\n+/).filter(p => p.trim().length > 0).length;

    return { words, chars, charsNoSpaces, sentences, paragraphs };
  }, [text]);

  const readingTime = useMemo(() => {
    const wordsPerMinute = 200;
    const minutes = Math.ceil(stats.words / wordsPerMinute);
    return minutes || 1;
  }, [stats.words]);

  return (
    <div className="word-counter">
      <textarea
        value={text}
        onChange={(e) => setText(e.target.value)}
        placeholder="Enter or paste your text here..."
        rows={10}
      />

      <div className="stats">
        <div className="stat">
          <span className="label">Words:</span>
          <span className="value">{stats.words}</span>
        </div>
        <div className="stat">
          <span className="label">Characters:</span>
          <span className="value">{stats.chars}</span>
        </div>
        <div className="stat">
          <span className="label">Characters (no spaces):</span>
          <span className="value">{stats.charsNoSpaces}</span>
        </div>
        <div className="stat">
          <span className="label">Sentences:</span>
          <span className="value">{stats.sentences}</span>
        </div>
        <div className="stat">
          <span className="label">Paragraphs:</span>
          <span className="value">{stats.paragraphs}</span>
        </div>
        <div className="stat">
          <span className="label">Reading time:</span>
          <span className="value">{readingTime} min</span>
        </div>
      </div>
    </div>
  );
}

export default WordCounter;

function countTwitterCharacters(text) {
  const TWITTER_LIMIT = 280;

  // Twitter counts most characters as 1
  // but some (emojis, some Unicode) count as 2
  let count = 0;

  for (const char of text) {
    const code = char.codePointAt(0);

    // Basic Latin, most common characters: 1 unit
    // Emoji and special characters: 2 units
    if (code >= 0x10000) {
      count += 2;  // Surrogate pair
    } else {
      count += 1;
    }
  }

  return {
    count,
    remaining: TWITTER_LIMIT - count,
    percentage: (count / TWITTER_LIMIT) * 100,
    isValid: count <= TWITTER_LIMIT
  };
}

// Usage with visual feedback
function TwitterCounter({ text, onChange }) {
  const stats = countTwitterCharacters(text);

  const getColor = () => {
    if (stats.remaining < 0) return 'red';
    if (stats.remaining < 20) return 'orange';
    return 'green';
  };

  return (
    <div>
      <textarea
        value={text}
        onChange={e => onChange(e.target.value)}
        maxLength={280}
      />
      <div style={{ color: getColor() }}>
        {stats.remaining} characters remaining
      </div>
      <div className="progress-bar">
        <div
          style={{
            width: `${Math.min(stats.percentage, 100)}%`,
            backgroundColor: getColor()
          }}
        />
      </div>
    </div>
  );
}

def count_words(text):
    """Count words in text"""
    words = text.split()
    return len([w for w in words if w.strip()])

def count_characters(text, include_spaces=True):
    """Count characters with or without spaces"""
    if include_spaces:
        return len(text)
    return len(text.replace(' ', '').replace('\n', '').replace('\t', ''))

def count_sentences(text):
    """Count sentences (basic)"""
    import re
    sentences = re.split(r'[.!?]+', text)
    return len([s for s in sentences if s.strip()])

def count_paragraphs(text):
    """Count paragraphs"""
    paragraphs = text.split('\n\n')
    return len([p for p in paragraphs if p.strip()])

# Usage
text = """This is a sample text.
It has multiple sentences and paragraphs.

This is the second paragraph."""

print(f"Words: {count_words(text)}")
print(f"Characters: {count_characters(text)}")
print(f"Sentences: {count_sentences(text)}")
print(f"Paragraphs: {count_paragraphs(text)}")

import re
from collections import Counter

class TextAnalyzer:
    def __init__(self, text):
        self.text = text
        self.clean_text = self._clean(text)

    def _clean(self, text):
        # Remove URLs
        text = re.sub(r'https?://\S+', '', text)
        # Remove emails
        text = re.sub(r'\S+@\S+', '', text)
        # Normalize whitespace
        return re.sub(r'\s+', ' ', text.strip())

    def word_count(self):
        words = self.clean_text.split()
        return len(words)

    def character_count(self, include_spaces=True):
        if include_spaces:
            return len(self.text)
        return len(re.sub(r'\s', '', self.text))

    def sentence_count(self):
        sentences = re.split(r'[.!?]+', self.clean_text)
        return len([s for s in sentences if s.strip()])

    def paragraph_count(self):
        paragraphs = self.text.split('\n\n')
        return len([p for p in paragraphs if p.strip()])

    def average_word_length(self):
        words = self.clean_text.split()
        if not words:
            return 0
        total_length = sum(len(word) for word in words)
        return round(total_length / len(words), 2)

    def most_common_words(self, n=10, min_length=4):
        words = [w.lower() for w in self.clean_text.split() if len(w) >= min_length]
        return Counter(words).most_common(n)

    def get_all_stats(self):
        return {
            'words': self.word_count(),
            'characters': self.character_count(True),
            'characters_no_spaces': self.character_count(False),
            'sentences': self.sentence_count(),
            'paragraphs': self.paragraph_count(),
            'avg_word_length': self.average_word_length(),
            'most_common': self.most_common_words(5)
        }

# Usage
analyzer = TextAnalyzer("""
    This is a comprehensive text analysis example.
    It demonstrates various text metrics and statistics.

    The analyzer can count words, characters, and more.
""")

import json
print(json.dumps(analyzer.get_all_stats(), indent=2))

def analyze_file(filename):
    """Analyze text file and return statistics"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            text = f.read()

        analyzer = TextAnalyzer(text)
        stats = analyzer.get_all_stats()

        # Add file-specific stats
        stats['file_size'] = os.path.getsize(filename)
        stats['lines'] = len(text.splitlines())

        return stats

    except FileNotFoundError:
        return {'error': f'File {filename} not found'}
    except Exception as e:
        return {'error': str(e)}

# Batch process multiple files
def analyze_directory(directory, extension='.txt'):
    """Analyze all text files in directory"""
    import os
    results = {}

    for filename in os.listdir(directory):
        if filename.endswith(extension):
            filepath = os.path.join(directory, filename)
            results[filename] = analyze_file(filepath)

    return results

# Usage
stats = analyze_file('document.txt')
print(f"Words: {stats.get('words', 0)}")
print(f"File size: {stats.get('file_size', 0)} bytes")

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords

# Download required data (first time only)
# nltk.download('punkt')
# nltk.download('stopwords')

def advanced_word_count(text):
    """Word count using NLTK tokenization"""
    tokens = word_tokenize(text)
    # Filter out punctuation
    words = [w for w in tokens if w.isalnum()]
    return len(words)

def content_words_only(text):
    """Count only content words (exclude stop words)"""
    tokens = word_tokenize(text.lower())
    stop_words = set(stopwords.words('english'))
    content_words = [w for w in tokens if w.isalnum() and w not in stop_words]
    return len(content_words)

def accurate_sentence_count(text):
    """More accurate sentence counting"""
    sentences = sent_tokenize(text)
    return len(sentences)

# Usage
text = "Dr. Smith has a Ph.D. from M.I.T. He's brilliant!"

print(f"Basic word count: {len(text.split())}")
print(f"NLTK word count: {advanced_word_count(text)}")
print(f"Content words: {content_words_only(text)}")
print(f"Sentences: {accurate_sentence_count(text)}")

<?php
function countWords($text) {
    $text = trim($text);
    if (empty($text)) return 0;

    $words = preg_split('/\s+/', $text);
    return count(array_filter($words));
}

function countCharacters($text, $includeSpaces = true) {
    if ($includeSpaces) {
        return mb_strlen($text);
    }
    return mb_strlen(preg_replace('/\s/', '', $text));
}

function countSentences($text) {
    $sentences = preg_split('/[.!?]+/', $text);
    return count(array_filter(array_map('trim', $sentences)));
}

function analyzeText($text) {
    return [
        'words' => countWords($text),
        'characters' => countCharacters($text),
        'charactersNoSpaces' => countCharacters($text, false),
        'sentences' => countSentences($text)
    ];
}

// Usage
$text = "Hello world! This is a test.";
$stats = analyzeText($text);
print_r($stats);
?>

public class TextAnalyzer {
    private String text;

    public TextAnalyzer(String text) {
        this.text = text;
    }

    public int countWords() {
        String trimmed = text.trim();
        if (trimmed.isEmpty()) return 0;

        String[] words = trimmed.split("\\s+");
        return words.length;
    }

    public int countCharacters(boolean includeSpaces) {
        if (includeSpaces) {
            return text.length();
        }
        return text.replaceAll("\\s", "").length();
    }

    public int countSentences() {
        String[] sentences = text.split("[.!?]+");
        int count = 0;
        for (String s : sentences) {
            if (!s.trim().isEmpty()) count++;
        }
        return count;
    }

    public Map<String, Integer> getAllStats() {
        Map<String, Integer> stats = new HashMap<>();
        stats.put("words", countWords());
        stats.put("characters", countCharacters(true));
        stats.put("sentences", countSentences());
        return stats;
    }

    public static void main(String[] args) {
        TextAnalyzer analyzer = new TextAnalyzer(
            "Hello world! This is a test."
        );
        System.out.println(analyzer.getAllStats());
    }
}

using System;
using System.Linq;
using System.Text.RegularExpressions;

public class TextAnalyzer
{
    private string text;

    public TextAnalyzer(string text)
    {
        this.text = text;
    }

    public int CountWords()
    {
        var trimmed = text.Trim();
        if (string.IsNullOrEmpty(trimmed)) return 0;

        var words = Regex.Split(trimmed, @"\s+");
        return words.Where(w => !string.IsNullOrEmpty(w)).Count();
    }

    public int CountCharacters(bool includeSpaces = true)
    {
        if (includeSpaces) return text.Length;
        return Regex.Replace(text, @"\s", "").Length;
    }

    public int CountSentences()
    {
        var sentences = Regex.Split(text, @"[.!?]+");
        return sentences.Where(s => !string.IsNullOrWhiteSpace(s)).Count();
    }

    public void PrintStats()
    {
        Console.WriteLine($"Words: {CountWords()}");
        Console.WriteLine($"Characters: {CountCharacters()}");
        Console.WriteLine($"Sentences: {CountSentences()}");
    }

    static void Main()
    {
        var analyzer = new TextAnalyzer("Hello world! This is a test.");
        analyzer.PrintStats();
    }
}

class TextAnalyzer
  def initialize(text)
    @text = text
  end

  def word_count
    @text.split(/\s+/).reject(&:empty?).length
  end

  def character_count(include_spaces: true)
    include_spaces ? @text.length : @text.gsub(/\s/, '').length
  end

  def sentence_count
    @text.split(/[.!?]+/).reject { |s| s.strip.empty? }.length
  end

  def all_stats
    {
      words: word_count,
      characters: character_count,
      characters_no_spaces: character_count(include_spaces: false),
      sentences: sentence_count
    }
  end
end

# Usage
analyzer = TextAnalyzer.new("Hello world! This is a test.")
puts analyzer.all_stats

function calculateReadingTime(text, wordsPerMinute = 200) {
  const words = text.trim().split(/\s+/).length;
  const minutes = words / wordsPerMinute;

  // Round up to nearest minute
  const readTime = Math.ceil(minutes);

  return {
    minutes: readTime,
    words: words,
    text: `${readTime} min read`
  };
}

// Usage
const article = `Your article text here...`;
const reading = calculateReadingTime(article);
console.log(reading.text);  // "5 min read"

function calculateAdvancedReadingTime(text, options = {}) {
  const {
    wordsPerMinute = 200,
    includeImages = true,
    imageTime = 12,          // Seconds per image
    codeBlockPenalty = 0.5,  // Slower reading for code
  } = options;

  // Count words
  let words = text.trim().split(/\s+/).length;

  // Count images (if HTML)
  let imageCount = 0;
  if (includeImages) {
    const imgMatches = text.match(/<img[^>]*>/gi);
    imageCount = imgMatches ? imgMatches.length : 0;
  }

  // Count code blocks
  const codeBlocks = text.match(/```[\s\S]*?```/g) || [];
  const codeWords = codeBlocks.join(' ').split(/\s+/).length;

  // Adjust for code blocks (slower reading)
  const regularWords = words - codeWords;
  const adjustedWords = regularWords + (codeWords * (1 + codeBlockPenalty));

  // Calculate time
  const wordTime = adjustedWords / wordsPerMinute;
  const imageTimeMinutes = (imageCount * imageTime) / 60;
  const totalMinutes = wordTime + imageTimeMinutes;

  const minutes = Math.ceil(totalMinutes);

  return {
    minutes,
    words,
    images: imageCount,
    text: `${minutes} min read`,
    details: {
      wordReadingTime: Math.ceil(wordTime),
      imageTime: Math.ceil(imageTimeMinutes),
      codeBlocks: codeBlocks.length
    }
  };
}

// Usage
const article = `
  Article with text, code blocks, and images...
  ```javascript
  const code = 'example';
  ```
  <img src="image.jpg" alt="Example">
`;

const reading = calculateAdvancedReadingTime(article, {
  wordsPerMinute: 200,
  includeImages: true
});

console.log(reading.text);
console.log(reading.details);

// Medium.com reading time calculation
function mediumReadingTime(text) {
  const wordsPerMinute = 265; // Medium uses 265 WPM

  const words = text.trim().split(/\s+/).length;
  const minutes = words / wordsPerMinute;

  // Medium shows decimal for < 1 min
  if (minutes < 1) {
    const seconds = Math.ceil(minutes * 60);
    return `${seconds} sec read`;
  }

  // Round to nearest minute
  const readTime = Math.round(minutes);

  // Medium style: "X min read"
  return `${readTime} min read`;
}

// With visual component
function ReadingTime({ text }) {
  const readingTime = mediumReadingTime(text);

  return (
    <div className="reading-time">
      <svg className="clock-icon" viewBox="0 0 24 24">
        <path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm.5-13H11v6l5.2 3.2.8-1.3-4.5-2.7V7z"/>
      </svg>
      <span>{readingTime}</span>
    </div>
  );
}

function calculateKeywordDensity(text, keyword) {
  const lowerText = text.toLowerCase();
  const lowerKeyword = keyword.toLowerCase();

  // Total word count
  const words = text.trim().split(/\s+/);
  const totalWords = words.length;

  // Count keyword occurrences
  const regex = new RegExp(`\\b${lowerKeyword}\\b`, 'gi');
  const matches = lowerText.match(regex);
  const keywordCount = matches ? matches.length : 0;

  // Calculate density
  const density = (keywordCount / totalWords) * 100;

  return {
    keyword,
    count: keywordCount,
    totalWords,
    density: density.toFixed(2),
    densityPercentage: `${density.toFixed(2)}%`,
    recommendation: getRecommendation(density)
  };
}

function getRecommendation(density) {
  if (density < 0.5) return 'Too low - consider adding keyword';
  if (density <= 2.5) return 'Optimal keyword density';
  if (density <= 3.5) return 'Slightly high - review usage';
  return 'Too high - risk of keyword stuffing';
}

// Multi-keyword analysis
function analyzeKeywords(text, keywords) {
  return keywords.map(keyword => calculateKeywordDensity(text, keyword));
}

// Usage
const article = "SEO is important. Good SEO practices improve rankings.";
const result = calculateKeywordDensity(article, 'SEO');

console.log(`Keyword: ${result.keyword}`);
console.log(`Count: ${result.count}`);
console.log(`Density: ${result.densityPercentage}`);
console.log(`Recommendation: ${result.recommendation}`);

// Analyze multiple keywords
const keywords = ['SEO', 'ranking', 'content'];
const analysis = analyzeKeywords(article, keywords);
console.table(analysis);

function analyzeSEO(text, title, meta) {
  const stats = {
    wordCount: text.trim().split(/\s+/).length,
    titleLength: title.length,
    metaLength: meta.length,
    readingTime: Math.ceil(text.split(/\s+/).length / 200),
    issues: [],
    warnings: [],
    passed: []
  };

  // Word count checks
  if (stats.wordCount < 300) {
    stats.issues.push('Content too short (< 300 words)');
  } else if (stats.wordCount >= 300 && stats.wordCount < 600) {
    stats.warnings.push('Content could be longer for better SEO');
  } else if (stats.wordCount >= 1500) {
    stats.passed.push('Excellent content length');
  } else {
    stats.passed.push('Good content length');
  }

  // Title checks
  if (stats.titleLength < 30) {
    stats.issues.push('Title too short (< 30 chars)');
  } else if (stats.titleLength > 60) {
    stats.warnings.push('Title may be truncated in search results');
  } else {
    stats.passed.push('Title length optimal');
  }

  // Meta description checks
  if (stats.metaLength < 120) {
    stats.warnings.push('Meta description too short');
  } else if (stats.metaLength > 160) {
    stats.warnings.push('Meta description may be truncated');
  } else {
    stats.passed.push('Meta description length optimal');
  }

  // Readability
  const sentences = text.split(/[.!?]+/).filter(s => s.trim()).length;
  const avgWordsPerSentence = stats.wordCount / sentences;

  if (avgWordsPerSentence > 25) {
    stats.warnings.push('Long sentences may hurt readability');
  } else if (avgWordsPerSentence < 10) {
    stats.warnings.push('Very short sentences - vary sentence length');
  } else {
    stats.passed.push('Good sentence length');
  }

  // Calculate score
  const totalChecks = stats.issues.length + stats.warnings.length + stats.passed.length;
  const score = Math.round((stats.passed.length / totalChecks) * 100);

  return {
    ...stats,
    score,
    grade: score >= 80 ? 'A' : score >= 60 ? 'B' : score >= 40 ? 'C' : 'D'
  };
}

// Usage
const result = analyzeSEO(
  'Your article content here...',
  'Complete SEO Guide for Beginners',
  'Learn SEO basics and improve your website ranking with this comprehensive guide'
);

console.log(`SEO Score: ${result.score}/100 (${result.grade})`);
console.log('Issues:', result.issues);
console.log('Warnings:', result.warnings);
console.log('Passed:', result.passed);

function countSyllables(word) {
  word = word.toLowerCase();
  if (word.length <= 3) return 1;

  word = word.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, '');
  word = word.replace(/^y/, '');

  const syllables = word.match(/[aeiouy]{1,2}/g);
  return syllables ? syllables.length : 1;
}

function calculateFleschReadingEase(text) {
  const sentences = text.split(/[.!?]+/).filter(s => s.trim()).length;
  const words = text.trim().split(/\s+/).length;
  const syllables = text.split(/\s+/)
    .reduce((total, word) => total + countSyllables(word), 0);

  if (sentences === 0 || words === 0) return 0;

  const score = 206.835 - 1.015 * (words / sentences) - 84.6 * (syllables / words);

  return {
    score: Math.round(score * 10) / 10,
    level: getReadingLevel(score),
    description: getReadingDescription(score)
  };
}

function getReadingLevel(score) {
  if (score >= 90) return '5th grade';
  if (score >= 80) return '6th grade';
  if (score >= 70) return '7th grade';
  if (score >= 60) return '8th-9th grade';
  if (score >= 50) return '10th-12th grade';
  if (score >= 30) return 'College';
  return 'College graduate';
}

function getReadingDescription(score) {
  if (score >= 90) return 'Very easy to read';
  if (score >= 80) return 'Easy to read';
  if (score >= 70) return 'Fairly easy to read';
  if (score >= 60) return 'Standard';
  if (score >= 50) return 'Fairly difficult';
  if (score >= 30) return 'Difficult';
  return 'Very difficult';
}

function calculateFleschKincaidGrade(text) {
  const sentences = text.split(/[.!?]+/).filter(s => s.trim()).length;
  const words = text.trim().split(/\s+/).length;
  const syllables = text.split(/\s+/)
    .reduce((total, word) => total + countSyllables(word), 0);

  if (sentences === 0 || words === 0) return 0;

  const grade = 0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59;

  return {
    grade: Math.round(grade * 10) / 10,
    level: `${Math.round(grade)}th grade`
  };
}

// Usage
const text = `
  This is a sample text for readability analysis.
  It contains multiple sentences with varying complexity.
  The readability score helps determine how easy the text is to read.
`;

const flesch = calculateFleschReadingEase(text);
const grade = calculateFleschKincaidGrade(text);

console.log('Flesch Reading Ease:', flesch.score);
console.log('Reading Level:', flesch.level);
console.log('Description:', flesch.description);
console.log('Flesch-Kincaid Grade:', grade.grade);

function analyzeWordFrequency(text, options = {}) {
  const {
    minLength = 3,
    maxResults = 20,
    excludeStopWords = true,
    caseSensitive = false
  } = options;

  // Common English stop words
  const stopWords = new Set([
    'the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have',
    'i', 'it', 'for', 'not', 'on', 'with', 'he', 'as', 'you',
    'do', 'at', 'this', 'but', 'his', 'by', 'from', 'they',
    'we', 'say', 'her', 'she', 'or', 'an', 'will', 'my', 'one',
    'all', 'would', 'there', 'their', 'what', 'so', 'up', 'out',
    'if', 'about', 'who', 'get', 'which', 'go', 'me', 'when',
    'make', 'can', 'like', 'time', 'no', 'just', 'him', 'know',
    'take', 'people', 'into', 'year', 'your', 'good', 'some',
    'could', 'them', 'see', 'other', 'than', 'then', 'now',
    'look', 'only', 'come', 'its', 'over', 'think', 'also',
    'back', 'after', 'use', 'two', 'how', 'our', 'work', 'first',
    'well', 'way', 'even', 'new', 'want', 'because', 'any',
    'these', 'give', 'day', 'most', 'us', 'is', 'was', 'are'
  ]);

  // Clean and split text
  const words = text
    .replace(/[^a-zA-Z0-9\s'-]/g, ' ')
    .split(/\s+/)
    .filter(word => word.length >= minLength)
    .map(word => caseSensitive ? word : word.toLowerCase())
    .filter(word => !excludeStopWords || !stopWords.has(word.toLowerCase()));

  // Count frequencies
  const frequency = {};
  words.forEach(word => {
    frequency[word] = (frequency[word] || 0) + 1;
  });

  // Sort by frequency
  const sorted = Object.entries(frequency)
    .sort((a, b) => b[1] - a[1])
    .slice(0, maxResults)
    .map(([word, count]) => ({
      word,
      count,
      percentage: ((count / words.length) * 100).toFixed(2)
    }));

  return {
    totalWords: words.length,
    uniqueWords: Object.keys(frequency).length,
    mostCommon: sorted
  };
}

// Usage
const text = `
  Text analysis is important for SEO. Good text analysis
  helps improve content quality. Text optimization requires
  careful analysis and planning.
`;

const analysis = analyzeWordFrequency(text, {
  minLength: 4,
  maxResults: 10,
  excludeStopWords: true
});

console.log(`Total words: ${analysis.totalWords}`);
console.log(`Unique words: ${analysis.uniqueWords}`);
console.table(analysis.mostCommon);

// Simple sentiment analysis
function analyzeSentiment(text) {
  // Positive words
  const positiveWords = new Set([
    'good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic',
    'best', 'love', 'perfect', 'beautiful', 'awesome', 'brilliant',
    'happy', 'glad', 'pleased', 'delighted', 'enjoy', 'impressive'
  ]);

  // Negative words
  const negativeWords = new Set([
    'bad', 'terrible', 'awful', 'horrible', 'worst', 'hate',
    'poor', 'disappointing', 'frustrating', 'angry', 'sad',
    'difficult', 'hard', 'problem', 'issue', 'wrong', 'failed'
  ]);

  // Intensifiers
  const intensifiers = new Set([
    'very', 'extremely', 'really', 'incredibly', 'absolutely',
    'totally', 'completely', 'highly', 'quite'
  ]);

  const words = text.toLowerCase().split(/\s+/);
  let score = 0;
  let positiveCount = 0;
  let negativeCount = 0;

  for (let i = 0; i < words.length; i++) {
    const word = words[i].replace(/[^a-z]/g, '');
    const prevWord = i > 0 ? words[i - 1].replace(/[^a-z]/g, '') : '';

    const multiplier = intensifiers.has(prevWord) ? 2 : 1;

    if (positiveWords.has(word)) {
      score += 1 * multiplier;
      positiveCount++;
    }

    if (negativeWords.has(word)) {
      score -= 1 * multiplier;
      negativeCount++;
    }
  }

  const totalSentimentWords = positiveCount + negativeCount;
  const sentiment = score > 0 ? 'positive' : score < 0 ? 'negative' : 'neutral';

  return {
    score,
    sentiment,
    positiveCount,
    negativeCount,
    totalSentimentWords,
    confidence: totalSentimentWords > 0
      ? Math.abs(score) / totalSentimentWords
      : 0
  };
}

// Usage
const texts = [
  "This is a great product! I love it!",
  "Terrible experience. Very disappointed.",
  "The product works as expected."
];

texts.forEach(text => {
  const sentiment = analyzeSentiment(text);
  console.log(`Text: ${text}`);
  console.log(`Sentiment: ${sentiment.sentiment} (score: ${sentiment.score})`);
  console.log('---');
});

class ComprehensiveTextAnalyzer {
  constructor(text) {
    this.text = text;
    this.words = this.getWords();
  }

  getWords() {
    return this.text
      .trim()
      .split(/\s+/)
      .filter(w => w.length > 0);
  }

  getBasicStats() {
    const chars = this.text.length;
    const charsNoSpaces = this.text.replace(/\s/g, '').length;
    const sentences = this.text.split(/[.!?]+/).filter(s => s.trim()).length;
    const paragraphs = this.text.split(/\n\n+/).filter(p => p.trim()).length;

    return {
      words: this.words.length,
      characters: chars,
      charactersNoSpaces: charsNoSpaces,
      sentences,
      paragraphs,
      averageWordLength: (charsNoSpaces / this.words.length).toFixed(2),
      averageWordsPerSentence: (this.words.length / sentences).toFixed(2)
    };
  }

  getReadingMetrics() {
    const words = this.words.length;
    const wpm = 200;
    const minutes = Math.ceil(words / wpm);

    return {
      readingTime: `${minutes} min read`,
      readingTimeMinutes: minutes,
      wordsPerMinute: wpm,
      estimatedWords: words
    };
  }

  getKeywordDensity(keyword) {
    const lowerText = this.text.toLowerCase();
    const regex = new RegExp(`\\b${keyword.toLowerCase()}\\b`, 'gi');
    const matches = lowerText.match(regex);
    const count = matches ? matches.length : 0;
    const density = (count / this.words.length) * 100;

    return {
      keyword,
      count,
      density: density.toFixed(2) + '%'
    };
  }

  getTopWords(n = 10) {
    const frequency = {};
    const stopWords = new Set(['the', 'be', 'to', 'of', 'and', 'a', 'in']);

    this.words
      .map(w => w.toLowerCase().replace(/[^a-z]/g, ''))
      .filter(w => w.length > 3 && !stopWords.has(w))
      .forEach(word => {
        frequency[word] = (frequency[word] || 0) + 1;
      });

    return Object.entries(frequency)
      .sort((a, b) => b[1] - a[1])
      .slice(0, n)
      .map(([word, count]) => ({ word, count }));
  }

  getAllStats() {
    return {
      basic: this.getBasicStats(),
      reading: this.getReadingMetrics(),
      topWords: this.getTopWords(5)
    };
  }
}

// Usage
const text = `
  Your comprehensive article text goes here.
  It should be a substantial piece of content
  with multiple paragraphs and sentences.
`;

const analyzer = new ComprehensiveTextAnalyzer(text);
const stats = analyzer.getAllStats();

console.log('=== Text Statistics ===');
console.log('Basic Stats:', stats.basic);
console.log('Reading Metrics:', stats.reading);
console.log('Top Words:', stats.topWords);

// Individual keyword analysis
const keywordStats = analyzer.getKeywordDensity('content');
console.log('Keyword Analysis:', keywordStats);