HTML to Text Html tools

// Simple HTML to text conversion
function htmlToText(html) {
    // Create a temporary element
    const temp = document.createElement('div');
    temp.innerHTML = html;
    
    // Handle line breaks
    temp.querySelectorAll('br').forEach(br => br.replaceWith('\n'));
    temp.querySelectorAll('p, div, h1, h2, h3, h4, h5, h6').forEach(block => {
        block.insertAdjacentText('afterend', '\n\n');
    });
    
    // Handle links
    temp.querySelectorAll('a').forEach(link => {
        const href = link.getAttribute('href');
        if (href) {
            link.textContent = `${link.textContent} [${href}]`;
        }
    });
    
    // Get text content
    return temp.textContent || temp.innerText || '';
}

// Using the API
async function convertWithAPI(html) {
    const response = await fetch('/tools/html-to-text', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
            html: html,
            preserve_links: true,
            preserve_breaks: true
        })
    });
    
    const result = await response.json();
    console.log('Converted text:', result.text);
    console.log('Statistics:', result.stats);
}

<?php
// Using PHP DOMDocument
function htmlToText($html, $options = []) {
    $dom = new DOMDocument();
    @$dom->loadHTML($html);
    
    // Remove scripts and styles
    $remove = ['script', 'style'];
    foreach ($remove as $tag) {
        $elements = $dom->getElementsByTagName($tag);
        while ($elements->length > 0) {
            $elements->item(0)->parentNode->removeChild($elements->item(0));
        }
    }
    
    // Get text content
    $text = $dom->textContent;
    
    // Clean up whitespace
    $text = preg_replace('/\s+/', ' ', $text);
    $text = trim($text);
    
    return $text;
}

// Advanced conversion with options
function advancedHtmlToText($html, $preserveLinks = true) {
    $dom = new DOMDocument();
    @$dom->loadHTML(mb_convert_encoding($html, 'HTML-ENTITIES', 'UTF-8'));
    
    if ($preserveLinks) {
        // Process links
        $links = $dom->getElementsByTagName('a');
        foreach ($links as $link) {
            $href = $link->getAttribute('href');
            if ($href) {
                $text = $link->textContent;
                $link->textContent = "$text [$href]";
            }
        }
    }
    
    // Process block elements
    $blocks = ['p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
    foreach ($blocks as $tag) {
        $elements = $dom->getElementsByTagName($tag);
        foreach ($elements as $element) {
            $element->appendChild($dom->createTextNode("\n\n"));
        }
    }
    
    return strip_tags($dom->saveHTML());
}
?>

from bs4 import BeautifulSoup
import requests

def html_to_text(html, preserve_links=True):
    """Convert HTML to plain text with options"""
    soup = BeautifulSoup(html, 'html.parser')
    
    # Remove script and style elements
    for script in soup(['script', 'style']):
        script.decompose()
    
    # Handle links
    if preserve_links:
        for link in soup.find_all('a'):
            href = link.get('href', '')
            if href:
                link.string = f"{link.get_text()} [{href}]"
    
    # Handle line breaks
    for br in soup.find_all('br'):
        br.replace_with('\n')
    
    # Get text
    text = soup.get_text(separator='\n')
    
    # Clean up
    lines = [line.strip() for line in text.splitlines()]
    text = '\n'.join(line for line in lines if line)
    
    return text

# HTML to Markdown conversion
def html_to_markdown(html):
    """Convert HTML to Markdown format"""
    import html2text
    
    h = html2text.HTML2Text()
    h.ignore_links = False
    h.ignore_images = False
    h.body_width = 0  # Don't wrap lines
    
    return h.handle(html)

# Using the API
def convert_with_api(html_content):
    response = requests.post('https://yourdomain.com/tools/html-to-text', 
        data={
            'html': html_content,
            'mode': 'standard',
            'preserve_links': 'true',
            'preserve_breaks': 'true'
        }
    )
    
    result = response.json()
    return result['text']

const cheerio = require('cheerio');
const TurndownService = require('turndown');

// HTML to Text
function htmlToText(html, options = {}) {
    const $ = cheerio.load(html);
    
    // Remove unwanted elements
    $('script, style').remove();
    
    // Handle links
    if (options.preserveLinks) {
        $('a').each((i, elem) => {
            const $elem = $(elem);
            const href = $elem.attr('href');
            if (href) {
                $elem.text(`${$elem.text()} [${href}]`);
            }
        });
    }
    
    // Handle images
    if (options.preserveImages) {
        $('img').each((i, elem) => {
            const $elem = $(elem);
            const alt = $elem.attr('alt') || 'Image';
            $elem.replaceWith(`[${alt}]`);
        });
    }
    
    // Handle lists
    $('ul, ol').each((i, elem) => {
        const $list = $(elem);
        const isOrdered = elem.name === 'ol';
        
        $list.find('li').each((index, li) => {
            const $li = $(li);
            const prefix = isOrdered ? `${index + 1}. ` : '• ';
            $li.prepend(prefix);
        });
    });
    
    // Get text
    let text = $.text();
    
    // Clean up whitespace
    text = text.replace(/\n\s*\n/g, '\n\n');
    text = text.trim();
    
    return text;
}

// HTML to Markdown
function htmlToMarkdown(html) {
    const turndownService = new TurndownService({
        headingStyle: 'atx',
        codeBlockStyle: 'fenced'
    });
    
    return turndownService.turndown(html);
}

// Express.js endpoint
app.post('/api/html-to-text', (req, res) => {
    const { html, mode, ...options } = req.body;
    
    try {
        let result;
        
        if (mode === 'markdown') {
            result = htmlToMarkdown(html);
        } else {
            result = htmlToText(html, options);
        }
        
        res.json({
            success: true,
            text: result,
            stats: {
                wordCount: result.split(/\s+/).length,
                charCount: result.length
            }
        });
    } catch (error) {
        res.status(400).json({
            error: 'Conversion failed',
            message: error.message
        });
    }
});