@wenathlan/saddle 1.8.17 → 2.0.2

package/docs/plans/18.research.content.extraction.md

@@ -1,1952 +0,0 @@
-# Pesquisa: Content Extraction Avançada (2026)
-
-## Table of Contents
-
-- [Visão Geral](#visão-geral)
-- [JSON-LD Extraction](#json-ld-extraction)
-- [Microdata Extraction](#microdata-extraction)
-- [OpenGraph / Twitter Card](#opengraph--twitter-card)
-- [RSS/Atom Feeds](#rssatom-feeds)
-- [Breadcrumb Extraction](#breadcrumb-extraction)
-- [Readable Content Extraction](#readable-content-extraction)
-- [HTML-to-Markdown](#html-to-markdown)
-- [Content Detection Heuristics](#content-detection-heuristics)
-- [API Interception Pattern](#api-interception-pattern)
-- [Structured Data First Approach](#structured-data-first-approach)
-- [Código Completo](#código-completo)
-
----
-
-## Visão Geral
-
-Content extraction é o processo de extrair dados estruturados e legíveis de HTML cru. Em 2026, a abordagem recomendada é **Structured Data First**: priorizar dados estruturados (JSON-LD, Microdata, OpenGraph) sobre extração de HTML bruto.
-
-### Prioridade de Extração
-
-```
-1. JSON-LD          → Dados estruturados mais completos e padronizados
-2. Microdata         → Schema.org inline (mais verboso que JSON-LD)
-3. OpenGraph/Twitter → Metadados de social sharing
-4. RSS/Atom          → Feeds de conteúdo
-5. HTML Readable     → Conteúdo principal legível (Readability)
-6. HTML Raw          → Extração via seletores CSS
-```
-
-### Bibliotecas Principais (2026)
-
-| Biblioteca | Versão | Uso |
-|---|---|---|
-| `cheerio` | 1.2.0 | Parsing HTML (jQuery-like) |
-| `@mozilla/readability` | 0.6.0 | Extração de conteúdo legível |
-| `turndown` | 7.2.4 | HTML → Markdown |
-| `node-html-markdown` | 2.0.0 | HTML → Markdown (mais rápido) |
-| `mdream` | 0.x | HTML → Markdown (Rust, 33x mais rápido) |
-| `open-graph-scraper` | 6.11.0 | Extração OpenGraph |
-| `feedsmith` | 2.x | Parsing RSS/Atom |
-| `rss-parser` | 3.13.0 | Parsing RSS/Atom |
-| `rss-finder` | 2.1.5 | Descoberta de feeds |
-
----
-
-## JSON-LD Extraction
-
-### Conceito
-
-JSON-LD (JSON for Linked Data) é o formato preferido para dados estruturados. Google, Bing e outros motores de busca priorizam JSON-LD sobre Microdata.
-
-### Estrutura JSON-LD
-
-```json
-{
-    "@context": "https://schema.org",
-    "@type": "Article",
-    "headline": "Como Criar um Web Scraper",
-    "author": {
-        "@type": "Person",
-        "name": "João Silva"
-    },
-    "datePublished": "2026-01-15",
-    "image": "https://example.com/image.jpg",
-    "publisher": {
-        "@type": "Organization",
-        "name": "DevThink",
-        "logo": {
-            "@type": "ImageObject",
-            "url": "https://example.com/logo.png"
-        }
-    }
-}
-```
-
-### Extração com Cheerio
-
-```ts
-import * as cheerio from 'cheerio';
-
-interface JsonLdData {
-    type: string;
-    data: Record<string, unknown>;
-    raw: string;
-}
-
-function extractJsonLd(html: string): JsonLdData[] {
-    const $ = cheerio.load(html);
-    const results: JsonLdData[] = [];
-
-    $('script[type="application/ld+json"]').each((_, element) => {
-        const raw = $(element).html();
-        if (!raw) return;
-
-        try {
-            const data = JSON.parse(raw);
-
-            // JSON-LD pode ser um objeto único ou array
-            if (Array.isArray(data)) {
-                for (const item of data) {
-                    results.push({
-                        type: item['@type'] ?? 'Unknown',
-                        data: item,
-                        raw: JSON.stringify(item),
-                    });
-                }
-            } else {
-                results.push({
-                    type: data['@type'] ?? 'Unknown',
-                    data,
-                    raw: JSON.stringify(data),
-                });
-            }
-        } catch (error) {
-            console.error('Erro ao parsear JSON-LD:', error);
-        }
-    });
-
-    return results;
-}
-
-// Usar
-const jsonLdItems = extractJsonLd(html);
-for (const item of jsonLdItems) {
-    console.log(`Type: ${item.type}`);
-
-    if (item.type === 'Article') {
-        console.log(`Title: ${item.data.headline}`);
-        console.log(`Author: ${(item.data.author as any)?.name}`);
-        console.log(`Date: ${item.data.datePublished}`);
-    }
-
-    if (item.type === 'Product') {
-        console.log(`Name: ${item.data.name}`);
-        console.log(`Price: ${(item.data.offers as any)?.price}`);
-    }
-
-    if (item.type === 'Organization') {
-        console.log(`Name: ${item.data.name}`);
-    }
-}
-```
-
-### Extração de Tipos Comuns
-
-```ts
-// Tipos JSON-LD comuns
-type JsonLdType =
-    | 'Article'
-    | 'NewsArticle'
-    | 'BlogPosting'
-    | 'Product'
-    | 'Organization'
-    | 'Person'
-    | 'BreadcrumbList'
-    | 'FAQPage'
-    | 'HowTo'
-    | 'Event'
-    | 'LocalBusiness'
-    | 'WebSite'
-    | 'WebPage';
-
-function extractJsonLdByType<T = Record<string, unknown>>(
-    html: string,
-    type: JsonLdType,
-): T[] {
-    const items = extractJsonLd(html);
-    return items
-        .filter(item => item.type === type)
-        .map(item => item.data as T);
-}
-
-// Extrair artigo
-interface ArticleData {
-    headline: string;
-    author: { name: string; url?: string };
-    datePublished: string;
-    dateModified?: string;
-    description?: string;
-    image?: string | string[];
-    publisher?: { name: string };
-    mainEntityOfPage?: string;
-}
-
-const articles = extractJsonLdByType<ArticleData>(html, 'Article');
-const article = articles[0];
-if (article) {
-    console.log(`Title: ${article.headline}`);
-    console.log(`Author: ${article.author.name}`);
-    console.log(`Published: ${article.datePublished}`);
-}
-
-// Extrair produto
-interface ProductData {
-    name: string;
-    description?: string;
-    image?: string | string[];
-    offers?: {
-        price: string;
-        priceCurrency: string;
-        availability: string;
-    };
-    brand?: { name: string };
-    sku?: string;
-    aggregateRating?: {
-        ratingValue: string;
-        reviewCount: string;
-    };
-}
-
-const products = extractJsonLdByType<ProductData>(html, 'Product');
-```
-
-### JSON-LD Composto (Graph)
-
-```ts
-// JSON-LD pode ter @graph com múltiplos tipos
-const graphJsonLd = {
-    "@context": "https://schema.org",
-    "@graph": [
-        {
-            "@type": "Organization",
-            "name": "DevThink",
-            "url": "https://example.com"
-        },
-        {
-            "@type": "WebSite",
-            "name": "DevThink Blog",
-            "url": "https://example.com",
-            "potentialAction": {
-                "@type": "SearchAction",
-                "target": "https://example.com/search?q={search_term_string}"
-            }
-        },
-        {
-            "@type": "Article",
-            "headline": "Meu Artigo"
-        }
-    ]
-};
-
-function extractFromGraph(html: string): Record<string, unknown>[] {
-    const $ = cheerio.load(html);
-    const results: Record<string, unknown>[] = [];
-
-    $('script[type="application/ld+json"]').each((_, element) => {
-        const raw = $(element).html();
-        if (!raw) return;
-
-        try {
-            const data = JSON.parse(raw);
-
-            if (data['@graph']) {
-                results.push(...data['@graph']);
-            } else if (data['@type']) {
-                results.push(data);
-            }
-        } catch {}
-    });
-
-    return results;
-}
-```
-
----
-
-## Microdata Extraction
-
-### Conceito
-
-Microdata usa atributos HTML (`itemscope`, `itemtype`, `itemprop`) para marcar dados estruturados inline.
-
-### Estrutura Microdata
-
-```html
-<div itemscope itemtype="https://schema.org/Article">
-    <h1 itemprop="headline">Como Criar um Web Scraper</h1>
-    <div itemprop="author" itemscope itemtype="https://schema.org/Person">
-        <span itemprop="name">João Silva</span>
-    </div>
-    <time itemprop="datePublished" datetime="2026-01-15">15 de Janeiro, 2026</time>
-    <img itemprop="image" src="https://example.com/image.jpg" alt="">
-    <div itemprop="articleBody">
-        <p>Conteúdo do artigo...</p>
-    </div>
-</div>
-```
-
-### Extração com Cheerio
-
-```ts
-import * as cheerio from 'cheerio';
-
-interface MicrodataItem {
-    type: string;
-    id?: string;
-    properties: Record<string, string | MicrodataItem[]>;
-}
-
-function extractMicrodata(html: string): MicrodataItem[] {
-    const $ = cheerio.load(html);
-    const results: MicrodataItem[] = [];
-
-    $('[itemscope]').each((_, element) => {
-        const $el = $(element);
-        const type = $el.attr('itemtype');
-        const id = $el.attr('itemid');
-
-        if (!type) return;
-
-        const properties: Record<string, string | MicrodataItem[]> = {};
-
-        // Extrair propriedades simples
-        $el.find('[itemprop]').each((_, prop) => {
-            const $prop = $(prop);
-            const name = $prop.attr('itemprop');
-            if (!name) return;
-
-            // Verificar se é um sub-item
-            if ($prop.attr('itemscope')) {
-                const subItems = extractMicrodata($.html($prop));
-                properties[name] = subItems;
-            } else {
-                // Valor pode estar em href, content, src, ou texto
-                const value = $prop.attr('content')
-                    ?? $prop.attr('href')
-                    ?? $prop.attr('src')
-                    ?? $prop.text().trim();
-
-                properties[name] = value;
-            }
-        });
-
-        results.push({ type, id, properties });
-    });
-
-    return results;
-}
-
-// Usar
-const items = extractMicrodata(html);
-for (const item of items) {
-    console.log(`Type: ${item.type}`);
-    console.log(`Properties:`, item.properties);
-}
-```
-
-### microdata-minimal (Alternativa)
-
-```ts
-// Package: microdata-minimal
-import { microdata } from 'microdata-minimal';
-
-const items = microdata(html);
-console.log(items);
-// → [{ type: 'https://schema.org/Article', properties: { headline: '...' } }]
-```
-
-### Microdata vs JSON-LD
-
-| Característica | Microdata | JSON-LD |
-|---|---|---|
-| Localização | Inline no HTML | Bloco `<script>` separado |
-| Verbosidade | Alta (atributos em cada elemento) | Baixa (objeto JSON) |
-| Legibilidade | Baixa | Alta |
-| Google Priority | 2º | 1º |
-| Mantimento | Difícil (acoplado ao HTML) | Fácil (bloco separado) |
-| Suporte a @graph | ❌ | ✅ |
-
----
-
-## OpenGraph / Twitter Card
-
-### Conceito
-
-OpenGraph (OG) e Twitter Card são metadados usados para social sharing. Menos completos que JSON-LD, mas universalmente suportados.
-
-### Tags OpenGraph Comuns
-
-```html
-<!-- OpenGraph -->
-<meta property="og:title" content="Título da Página">
-<meta property="og:description" content="Descrição da Página">
-<meta property="og:image" content="https://example.com/image.jpg">
-<meta property="og:url" content="https://example.com/page">
-<meta property="og:type" content="article">
-<meta property="og:site_name" content="DevThink">
-<meta property="og:locale" content="pt_BR">
-<meta property="og:image:width" content="1200">
-<meta property="og:image:height" content="630">
-
-<!-- Twitter Card -->
-<meta name="twitter:card" content="summary_large_image">
-<meta name="twitter:site" content="@wenathlan">
-<meta name="twitter:creator" content="@nasblor">
-<meta name="twitter:title" content="Título da Página">
-<meta name="twitter:description" content="Descrição da Página">
-<meta name="twitter:image" content="https://example.com/image.jpg">
-```
-
-### Extração com Cheerio
-
-```ts
-import * as cheerio from 'cheerio';
-
-interface OpenGraphData {
-    title?: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-    siteName?: string;
-    locale?: string;
-    imageWidth?: string;
-    imageHeight?: string;
-}
-
-interface TwitterCardData {
-    card?: string;
-    site?: string;
-    creator?: string;
-    title?: string;
-    description?: string;
-    image?: string;
-}
-
-interface SocialMeta {
-    openGraph: OpenGraphData;
-    twitter: TwitterCardData;
-}
-
-function extractSocialMeta(html: string): SocialMeta {
-    const $ = cheerio.load(html);
-
-    const openGraph: OpenGraphData = {};
-    const twitter: TwitterCardData = {};
-
-    // OpenGraph
-    $('meta[property^="og:"]').each((_, element) => {
-        const property = $(element).attr('property')?.replace('og:', '');
-        const content = $(element).attr('content');
-        if (property && content) {
-            (openGraph as any)[property] = content;
-        }
-    });
-
-    // Twitter Card
-    $('meta[name^="twitter:"]').each((_, element) => {
-        const name = $(element).attr('name')?.replace('twitter:', '');
-        const content = $(element).attr('content');
-        if (name && content) {
-            (twitter as any)[name] = content;
-        }
-    });
-
-    return { openGraph, twitter };
-}
-
-// Usar
-const social = extractSocialMeta(html);
-console.log(social.openGraph.title);
-console.log(social.twitter.card);
-```
-
-### open-graph-scraper 6.11.0
-
-```ts
-import og from 'open-graph-scraper';
-
-const options = {
-    url: 'https://example.com',
-};
-
-const result = await og(options);
-if (result.success) {
-    const { ogTitle, ogDescription, ogImage, ogUrl, ogType } = result.result;
-    console.log(`Title: ${ogTitle}`);
-    console.log(`Description: ${ogDescription}`);
-    console.log(`Image: ${ogImage}`);
-}
-```
-
-### ogie (Mais Moderno)
-
-```ts
-import ogie from 'ogie';
-
-const result = await ogie('https://example.com');
-console.log(result);
-// → { title: '...', description: '...', image: '...', ... }
-```
-
----
-
-## RSS/Atom Feeds
-
-### feedsmith 2.x (Mais Rápido)
-
-`feedsmith` é o parser de feeds mais rápido em 2026. Suporta RSS 1.0, RSS 2.0, Atom, e JSON Feed.
-
-```ts
-import { parseFeed } from 'feedsmith';
-
-const rssXml = `
-<rss version="2.0">
-    <channel>
-        <title>Meu Blog</title>
-        <link>https://example.com</link>
-        <description>Descrição do blog</description>
-        <item>
-            <title>Artigo 1</title>
-            <link>https://example.com/artigo-1</link>
-            <description>Descrição do artigo 1</description>
-            <pubDate>Mon, 15 Jan 2026 10:00:00 GMT</pubDate>
-            <guid>https://example.com/artigo-1</guid>
-        </item>
-        <item>
-            <title>Artigo 2</title>
-            <link>https://example.com/artigo-2</link>
-            <description>Descrição do artigo 2</description>
-            <pubDate>Tue, 16 Jan 2026 10:00:00 GMT</pubDate>
-        </item>
-    </channel>
-</rss>
-`;
-
-const feed = parseFeed(rssXml);
-console.log(`Feed: ${feed.title}`);
-console.log(`Link: ${feed.link}`);
-console.log(`Items: ${feed.items.length}`);
-
-for (const item of feed.items) {
-    console.log(`  - ${item.title}`);
-    console.log(`    Link: ${item.link}`);
-    console.log(`    Date: ${item.pubDate}`);
-}
-```
-
-### rss-parser 3.13.0
-
-```ts
-import RSSParser from 'rss-parser';
-
-const parser = new RSSParser({
-    customFields: {
-        item: ['media:content', 'media:thumbnail'],
-    },
-});
-
-const feed = await parser.parseURL('https://example.com/feed.xml');
-console.log(`Title: ${feed.title}`);
-console.log(`Items: ${feed.items.length}`);
-
-for (const item of feed.items) {
-    console.log(`  - ${item.title}`);
-    console.log(`    Link: ${item.link}`);
-    console.log(`    Date: ${item.pubDate}`);
-    console.log(`    Creator: ${item.creator}`);
-}
-```
-
-### rss-finder 2.1.5 (Descoberta de Feeds)
-
-`rss-finder` descobre automaticamente feeds RSS/Atom em uma página HTML.
-
-```ts
-import { findRssFeeds } from 'rss-finder';
-
-const feeds = await findRssFeeds('https://example.com');
-console.log(feeds);
-// → [
-//   { title: 'Meu Blog RSS', url: 'https://example.com/feed.xml', type: 'application/rss+xml' },
-//   { title: 'Meu Blog Atom', url: 'https://example.com/atom.xml', type: 'application/atom+xml' },
-// ]
-
-// Usar com rss-parser
-const parser = new RSSParser();
-const feed = await parser.parseURL(feeds[0].url);
-```
-
-### Descoberta + Parse Combinados
-
-```ts
-import { findRssFeeds } from 'rss-finder';
-import { parseFeed } from 'feedsmith';
-import { gotScraping } from 'got-scraping';
-
-async function discoverAndParseFeed(
-    url: string,
-): Promise<{ feed: any; items: any[] } | null> {
-    // 1. Descobrir feeds
-    const feeds = await findRssFeeds(url);
-    if (feeds.length === 0) {
-        console.log(`Nenhum feed encontrado em ${url}`);
-        return null;
-    }
-
-    console.log(`Encontrados ${feeds.length} feeds`);
-
-    // 2. Parsear o primeiro feed
-    const feedUrl = feeds[0].url;
-    const response = await gotScraping(feedUrl);
-    const feed = parseFeed(response.body);
-
-    return {
-        feed: {
-            title: feed.title,
-            link: feed.link,
-            description: feed.description,
-        },
-        items: feed.items.map(item => ({
-            title: item.title,
-            link: item.link,
-            description: item.description,
-            pubDate: item.pubDate,
-            author: item.author,
-        })),
-    };
-}
-
-const result = await discoverAndParseFeed('https://example.com');
-if (result) {
-    console.log(`Feed: ${result.feed.title}`);
-    for (const item of result.items) {
-        console.log(`  - ${item.title}`);
-    }
-}
-```
-
----
-
-## Breadcrumb Extraction
-
-### JSON-LD BreadcrumbList
-
-```json
-{
-    "@context": "https://schema.org",
-    "@type": "BreadcrumbList",
-    "itemListElement": [
-        {
-            "@type": "ListItem",
-            "position": 1,
-            "name": "Home",
-            "item": "https://example.com"
-        },
-        {
-            "@type": "ListItem",
-            "position": 2,
-            "name": "Produtos",
-            "item": "https://example.com/products"
-        },
-        {
-            "@type": "ListItem",
-            "position": 3,
-            "name": "Produto X",
-            "item": "https://example.com/products/x"
-        }
-    ]
-}
-```
-
-```ts
-import * as cheerio from 'cheerio';
-
-interface BreadcrumbItem {
-    name: string;
-    url: string;
-    position: number;
-}
-
-function extractBreadcrumbs(html: string): BreadcrumbItem[] {
-    const $ = cheerio.load(html);
-
-    // 1. Tentar JSON-LD primeiro
-    const jsonLdBreadcrumbs = extractJsonLdBreadcrumbs(html);
-    if (jsonLdBreadcrumbs.length > 0) return jsonLdBreadcrumbs;
-
-    // 2. Tentar Microdata
-    const microdataBreadcrumbs = extractMicrodataBreadcrumbs(html);
-    if (microdataBreadcrumbs.length > 0) return microdataBreadcrumbs;
-
-    // 3. Fallback: HTML nav
-    return extractHtmlBreadcrumbs($);
-}
-
-function extractJsonLdBreadcrumbs(html: string): BreadcrumbItem[] {
-    const $ = cheerio.load(html);
-    const breadcrumbs: BreadcrumbItem[] = [];
-
-    $('script[type="application/ld+json"]').each((_, element) => {
-        const raw = $(element).html();
-        if (!raw) return;
-
-        try {
-            const data = JSON.parse(raw);
-            if (data['@type'] === 'BreadcrumbList' && data.itemListElement) {
-                for (const item of data.itemListElement) {
-                    breadcrumbs.push({
-                        name: item.name,
-                        url: item.item,
-                        position: item.position,
-                    });
-                }
-            }
-        } catch {}
-    });
-
-    return breadcrumbs.sort((a, b) => a.position - b.position);
-}
-
-function extractMicrodataBreadcrumbs(html: string): BreadcrumbItem[] {
-    const $ = cheerio.load(html);
-    const breadcrumbs: BreadcrumbItem[] = [];
-
-    $('[itemtype="https://schema.org/BreadcrumbList"] [itemtype="https://schema.org/ListItem"]').each((_, element) => {
-        const $item = $(element);
-        const name = $item.find('[itemprop="name"]').text().trim();
-        const url = $item.find('[itemprop="item"]').attr('href') ?? '';
-        const position = Number.parseInt($item.find('[itemprop="position"]').text() ?? '0', 10);
-
-        if (name) {
-            breadcrumbs.push({ name, url, position });
-        }
-    });
-
-    return breadcrumbs.sort((a, b) => a.position - b.position);
-}
-
-function extractHtmlBreadcrumbs($: cheerio.CheerioAPI): BreadcrumbItem[] {
-    const breadcrumbs: BreadcrumbItem[] = [];
-
-    // Seletores comuns para breadcrumbs
-    const selectors = [
-        'nav[aria-label="breadcrumb"] a',
-        'ol.breadcrumb a',
-        '.breadcrumb a',
-        '[itemtype="https://schema.org/BreadcrumbList"] a',
-    ];
-
-    for (const selector of selectors) {
-        $(selector).each((index, element) => {
-            const name = $(element).text().trim();
-            const url = $(element).attr('href') ?? '';
-
-            if (name) {
-                breadcrumbs.push({
-                    name,
-                    url,
-                    position: index + 1,
-                });
-            }
-        });
-
-        if (breadcrumbs.length > 0) break;
-    }
-
-    return breadcrumbs;
-}
-```
-
-### Exemplo de Uso
-
-```ts
-const breadcrumbs = extractBreadcrumbs(html);
-if (breadcrumbs.length > 0) {
-    const path = breadcrumbs.map(b => b.name).join(' > ');
-    console.log(`Breadcrumb: ${path}`);
-    // → "Breadcrumb: Home > Produtos > Produto X"
-}
-```
-
----
-
-## Readable Content Extraction
-
-### @mozilla/readability 0.6.0
-
-`@mozilla/readability` é a mesma biblioteca usada pelo Firefox Reader View. Extrai o conteúdo principal de uma página, removendo navigation, sidebars, ads, etc.
-
-```ts
-import { JSDOM } from 'jsdom';
-import { Readability } from '@mozilla/readability';
-
-function extractReadableContent(html: string, url = ''): {
-    title: string;
-    content: string;
-    textContent: string;
-    length: number;
-    excerpt: string;
-    byline: string;
-    dir: string;
-    siteName: string;
-    lang: string;
-} | null {
-    const dom = new JSDOM(html, { url });
-    const document = dom.window.document;
-
-    const reader = new Readability(document, {
-        charThreshold: 100,       // Mínimo de caracteres
-        keepClasses: false,       // Remover classes CSS
-        nbTopCandidates: 5,       // Top 5 candidates
-    });
-
-    const article = reader.parse();
-    if (!article) return null;
-
-    return {
-        title: article.title,
-        content: article.content,        // HTML limpo
-        textContent: article.textContent, // Texto puro
-        length: article.length,
-        excerpt: article.excerpt,
-        byline: article.byline,
-        dir: article.dir,
-        siteName: article.siteName,
-        lang: article.lang,
-    };
-}
-
-// Usar
-const readable = extractReadableContent(html, 'https://example.com/article');
-if (readable) {
-    console.log(`Title: ${readable.title}`);
-    console.log(`Author: ${readable.byline}`);
-    console.log(`Length: ${readable.length} chars`);
-    console.log(`Excerpt: ${readable.excerpt}`);
-    console.log(`Content: ${readable.textContent.substring(0, 200)}...`);
-}
-```
-
-### defuddle (Alternativa)
-
-`defuddle` é uma alternativa ao Readability com foco em extração de conteúdo para e-readers.
-
-```ts
-import { defuddle } from 'defuddle';
-
-const result = await defuddle(html, {
-    url: 'https://example.com',
-});
-
-console.log(result.title);
-console.log(result.content); // Markdown formatado
-console.log(result.excerpt);
-console.log(result.siteName);
-```
-
-### Comparação Readability vs Defuddle
-
-| Feature | @mozilla/readability | defuddle |
-|---|---|---|
-| Output | HTML | Markdown |
-| Velocidade | ⭐⭐⭐⭐ | ⭐⭐⭐ |
-| Qualidade | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
-| Metadata | Básico | Completo |
-| Manutenção | Mozilla (ativo) | Comunidade |
-| Node.js | Via jsdom | Nativo |
-
----
-
-## HTML-to-Markdown
-
-### turndown 7.2.4 (Padrão)
-
-`turndown` é o conversor HTML→Markdown mais popular. Usado pelo `@wenathlan/webscrape`.
-
-```ts
-import TurndownService from 'turndown';
-
-const turndown = new TurndownService({
-    headingStyle: 'atx',           # Heading
-    hr: '---',                     # Horizontal rule
-    bulletListMarker: '-',         # Lista
-    codeBlockStyle: 'fenced',      # Code block
-    fence: '```',                  # Fence
-    emDelimiter: '*',              # Itálico
-    strongDelimiter: '**',         # Bold
-    linkStyle: 'inlined',          # Links
-    linkReferenceStyle: 'full',    # Link references
-});
-
-// Customizar regras
-turndown.addRule('customImages', {
-    filter: 'img',
-    replacement(content, node) {
-        const alt = node.getAttribute('alt') ?? '';
-        const src = node.getAttribute('src') ?? '';
-        return `![${alt}](${src})`;
-    },
-});
-
-// Adicionar keep para preservar elementos
-turndown.keep(['iframe', 'video']);
-
-// Remover elementos
-turndown.remove(['script', 'style', 'nav', 'footer', 'aside']);
-
-const markdown = turndown.turndown(html);
-console.log(markdown);
-```
-
-### node-html-markdown 2.0.0 (1.57x Mais Rápido)
-
-```ts
-import { NodeHtmlMarkdown } from 'node-html-markdown';
-
-const nhm = new NodeHtmlMarkdown({
-    bulletMarker: '-',
-    codeBlockStyle: 'fenced',
-    useLinkReferenceDefinitions: false,
-});
-
-const markdown = nhm.translate(html);
-console.log(markdown);
-```
-
-### mdream (Rust, 33x Mais Rápido)
-
-```ts
-// mdream é um conversor Rust compilado para WASM
-// Performance: 33x mais rápido que turndown
-import { convert } from 'mdream';
-
-const markdown = convert(html, {
-    // Opções de conversão
-});
-```
-
-### Comparação de Performance
-
-| Biblioteca | Velocidade (1MB HTML) | Tamanho | linguagem |
-|---|---|---|---|
-| turndown | ~500ms | ~200KB | JavaScript |
-| node-html-markdown | ~320ms | ~150KB | JavaScript |
-| mdream | ~15ms | ~500KB | Rust/WASM |
-
-### Conversão com Preservação de Estrutura
-
-```ts
-import TurndownService from 'turndown';
-
-function htmlToMarkdownWithStructure(html: string): string {
-    const turndown = new TurndownService({
-        headingStyle: 'atx',
-        codeBlockStyle: 'fenced',
-        bulletListMarker: '-',
-    });
-
-    // Preservar tabelas
-    turndown.addRule('tables', {
-        filter: 'table',
-        replacement(content, node) {
-            // Implementação de tabela Markdown
-            const rows: string[] = [];
-            const headers: string[] = [];
-
-            node.querySelectorAll('thead th, th').forEach(th => {
-                headers.push(th.textContent?.trim() ?? '');
-            });
-
-            node.querySelectorAll('tbody tr, tr').forEach(tr => {
-                const cells: string[] = [];
-                tr.querySelectorAll('td').forEach(td => {
-                    cells.push(td.textContent?.trim() ?? '');
-                });
-                if (cells.length > 0) rows.push(cells.join(' | '));
-            });
-
-            if (headers.length === 0) return content;
-
-            const headerRow = headers.join(' | ');
-            const separator = headers.map(() => '---').join(' | ');
-            const bodyRows = rows.join('\n');
-
-            return `\n\n${headerRow}\n${separator}\n${bodyRows}\n\n`;
-        },
-    });
-
-    // Preservar code blocks
-    turndown.addRule('codeBlocks', {
-        filter(node) {
-            return (
-                node.nodeName === 'PRE' &&
-                node.firstChild &&
-                node.firstChild.nodeName === 'CODE'
-            );
-        },
-        replacement(content, node) {
-            const code = node.querySelector('code');
-            const language = code?.className?.match(/language-(\w+)/)?.[1] ?? '';
-            const text = code?.textContent ?? node.textContent ?? '';
-            return `\n\n\`\`\`${language}\n${text.trim()}\n\`\`\`\n\n`;
-        },
-    });
-
-    // Preservar imagens com caption
-    turndown.addRule('figures', {
-        filter: 'figure',
-        replacement(content, node) {
-            const img = node.querySelector('img');
-            const caption = node.querySelector('figcaption')?.textContent?.trim();
-
-            if (!img) return content;
-
-            const src = img.getAttribute('src') ?? '';
-            const alt = img.getAttribute('alt') ?? caption ?? '';
-
-            return `\n\n![${alt}](${src})${caption ? `\n*${caption}*` : ''}\n\n`;
-        },
-    });
-
-    return turndown.turndown(html);
-}
-```
-
----
-
-## Content Detection Heuristics
-
-### Static vs SPA vs Hydrated
-
-```ts
-interface DetectionResult {
-    type: 'static' | 'spa' | 'hydrated' | 'api-driven';
-    confidence: number;
-    indicators: string[];
-}
-
-function detectContentType(html: string, scripts: string[]): DetectionResult {
-    const indicators: string[] = [];
-    let spaScore = 0;
-    let staticScore = 0;
-    let hydratedScore = 0;
-
-    // SPA indicators
-    if (html.includes('__NEXT_DATA__') || html.includes('_next/data')) {
-        spaScore += 3;
-        indicators.push('Next.js data');
-    }
-    if (html.includes('__NUXT__') || html.includes('_nuxt/')) {
-        spaScore += 3;
-        indicators.push('Nuxt.js data');
-    }
-    if (html.includes('window.__INITIAL_STATE__')) {
-        spaScore += 2;
-        indicators.push('Initial state');
-    }
-    if (html.includes('data-reactroot') || html.includes('data-reactroot')) {
-        spaScore += 2;
-        indicators.push('React root');
-    }
-    if (html.includes('ng-app') || html.includes('ng-controller')) {
-        spaScore += 3;
-        indicators.push('Angular');
-    }
-    if (html.includes('id="app"') && scripts.some(s => s.includes('vue'))) {
-        spaScore += 3;
-        indicators.push('Vue.js');
-    }
-
-    // Static indicators
-    if (!scripts.some(s => s.includes('react') || s.includes('vue') || s.includes('angular'))) {
-        staticScore += 2;
-        indicators.push('No SPA framework detected');
-    }
-    if (html.match(/<article[\s>]/i)) {
-        staticScore += 1;
-        indicators.push('Article tag present');
-    }
-
-    // Hydrated indicators (SPA with server-rendered content)
-    if (spaScore > 0 && html.match(/<article[\s>]/i)) {
-        hydratedScore += 2;
-        indicators.push('SSR with article content');
-    }
-    if (spaScore > 0 && html.includes('__NEXT_DATA__')) {
-        hydratedScore += 2;
-        indicators.push('Next.js SSR');
-    }
-
-    // Determine type
-    if (hydratedScore > spaScore && hydratedScore > staticScore) {
-        return { type: 'hydrated', confidence: 0.8, indicators };
-    }
-    if (spaScore > staticScore) {
-        return { type: 'spa', confidence: 0.7, indicators };
-    }
-    return { type: 'static', confidence: 0.9, indicators };
-}
-
-// Usar
-const detection = detectContentType(html, scriptUrls);
-console.log(`Type: ${detection.type} (confidence: ${detection.confidence})`);
-console.log(`Indicators: ${detection.indicators.join(', ')}`);
-```
-
-### Detecção de Framework
-
-```ts
-interface FrameworkDetection {
-    framework: string | null;
-    version?: string;
-    renderer: 'ssr' | 'csr' | 'ssg';
-}
-
-function detectFramework(html: string): FrameworkDetection {
-    // Next.js
-    if (html.includes('__NEXT_DATA__')) {
-        const versionMatch = html.match(/"buildId":"([^"]+)"/);
-        return {
-            framework: 'next.js',
-            version: versionMatch?.[1],
-            renderer: 'ssr',
-        };
-    }
-
-    // Nuxt.js
-    if (html.includes('__NUXT__')) {
-        return { framework: 'nuxt.js', renderer: 'ssr' };
-    }
-
-    // Gatsby
-    if (html.includes('___gatsby')) {
-        return { framework: 'gatsby', renderer: 'ssg' };
-    }
-
-    // Angular Universal
-    if (html.includes('ng-server-app') || html.includes('TransferState')) {
-        return { framework: 'angular', renderer: 'ssr' };
-    }
-
-    // Remix
-    if (html.includes('__remixContext')) {
-        return { framework: 'remix', renderer: 'ssr' };
-    }
-
-    // Astro
-    if (html.includes('astro-island')) {
-        return { framework: 'astro', renderer: 'ssr' };
-    }
-
-    return { framework: null, renderer: 'csr' };
-}
-```
-
----
-
-## API Interception Pattern
-
-### Pular o Browser Totalmente
-
-Para sites que usam APIs internas, interceptar as chamadas de rede é mais rápido e eficiente que renderizar o browser.
-
-```ts
-import { chromium } from 'playwright';
-
-interface InterceptedAPI {
-    url: string;
-    method: string;
-    status: number;
-    body: unknown;
-    timestamp: number;
-}
-
-async function scrapeWithAPIInterception(
-    targetUrl: string,
-    apiPattern: RegExp,
-): Promise<{ page: any; apiData: InterceptedAPI[] }> {
-    const browser = await chromium.launch();
-    const context = await browser.newContext();
-    const page = await context.newPage();
-
-    const intercepted: InterceptedAPI[] = [];
-
-    // Interceptar requests de API
-    page.on('response', async (response) => {
-        const url = response.url();
-
-        if (apiPattern.test(url)) {
-            try {
-                const body = await response.json();
-                intercepted.push({
-                    url,
-                    method: response.request().method(),
-                    status: response.status(),
-                    body,
-                    timestamp: Date.now(),
-                });
-                console.log(`API intercepted: ${url}`);
-            } catch {
-                // Response não é JSON
-            }
-        }
-    });
-
-    await page.goto(targetUrl, { waitUntil: 'networkidle' });
-
-    return { page, apiData: intercepted };
-}
-
-// Usar
-const { page, apiData } = await scrapeWithAPIInterception(
-    'https://example.com/products',
-    /\/api\/products/,
-);
-
-console.log(`Interceptadas ${apiData.length} chamadas de API`);
-for (const api of apiData) {
-    console.log(`  ${api.method} ${api.url} → ${api.status}`);
-    console.log(`  Data:`, api.body);
-}
-```
-
-### API Interception com Filtros
-
-```ts
-interface APIFilter {
-    method?: string[];
-    status?: number[];
-    contentType?: string[];
-    pattern: RegExp;
-}
-
-async function scrapeWithFilteredAPI(
-    targetUrl: string,
-    filters: APIFilter[],
-): Promise<Map<string, unknown[]>> {
-    const browser = await chromium.launch();
-    const context = await browser.newContext();
-    const page = await context.newPage();
-
-    const results = new Map<string, unknown[]>();
-
-    page.on('response', async (response) => {
-        const url = response.url();
-        const method = response.request().method();
-        const status = response.status();
-        const contentType = response.headers()['content-type'] ?? '';
-
-        for (const filter of filters) {
-            const matches =
-                filter.pattern.test(url) &&
-                (!filter.method || filter.method.includes(method)) &&
-                (!filter.status || filter.status.includes(status)) &&
-                (!filter.contentType || filter.contentType.some(ct => contentType.includes(ct)));
-
-            if (matches) {
-                try {
-                    const body = await response.json();
-                    const key = filter.pattern.source;
-                    if (!results.has(key)) results.set(key, []);
-                    results.get(key)!.push(body);
-                } catch {}
-            }
-        }
-    });
-
-    await page.goto(targetUrl, { waitUntil: 'networkidle' });
-    await browser.close();
-
-    return results;
-}
-```
-
-### Extraindo Dados de APIs Interceptadas
-
-```ts
-interface Product {
-    id: string;
-    name: string;
-    price: number;
-    image: string;
-}
-
-async function extractProductsFromAPI(
-    categoryUrl: string,
-): Promise<Product[]> {
-    const browser = await chromium.launch();
-    const context = await browser.newContext();
-    const page = await context.newPage();
-
-    const products: Product[] = [];
-
-    page.on('response', async (response) => {
-        if (response.url().includes('/api/products')) {
-            try {
-                const data = await response.json();
-                if (Array.isArray(data.products)) {
-                    products.push(...data.products);
-                }
-            } catch {}
-        }
-    });
-
-    await page.goto(categoryUrl, { waitUntil: 'networkidle' });
-
-    // Scroll para carregar mais produtos (lazy loading)
-    await page.evaluate(async () => {
-        await new Promise((resolve) => {
-            let totalHeight = 0;
-            const distance = 500;
-            const timer = setInterval(() => {
-                window.scrollBy(0, distance);
-                totalHeight += distance;
-                if (totalHeight >= document.body.scrollHeight) {
-                    clearInterval(timer);
-                    resolve(undefined);
-                }
-            }, 200);
-        });
-    });
-
-    // Aguardar requests de API
-    await page.waitForTimeout(2000);
-
-    await browser.close();
-
-    // Deduplicar por ID
-    const seen = new Set<string>();
-    return products.filter(p => {
-        if (seen.has(p.id)) return false;
-        seen.add(p.id);
-        return true;
-    });
-}
-```
-
----
-
-## Structured Data First Approach
-
-### Estratégia de Extração em Cascata
-
-```ts
-import * as cheerio from 'cheerio';
-import { Readability } from '@mozilla/readability';
-import { JSDOM } from 'jsdom';
-
-interface ExtractedData {
-    source: 'json-ld' | 'microdata' | 'og' | 'readability' | 'html';
-    type: string;
-    title: string;
-    description?: string;
-    author?: string;
-    date?: string;
-    image?: string;
-    content: string;
-    url: string;
-    metadata: Record<string, unknown>;
-}
-
-function extractWithPriority(html: string, url: string): ExtractedData | null {
-    // 1. Tentar JSON-LD
-    const jsonLdResult = extractFromJsonLd(html, url);
-    if (jsonLdResult) return jsonLdResult;
-
-    // 2. Tentar Microdata
-    const microdataResult = extractFromMicrodata(html, url);
-    if (microdataResult) return microdataResult;
-
-    // 3. Tentar OpenGraph
-    const ogResult = extractFromOpenGraph(html, url);
-    if (ogResult) return ogResult;
-
-    // 4. Fallback: Readability
-    const readableResult = extractFromReadability(html, url);
-    if (readableResult) return readableResult;
-
-    // 5. Último recurso: HTML cru
-    return extractFromHtml(html, url);
-}
-
-function extractFromJsonLd(html: string, url: string): ExtractedData | null {
-    const $ = cheerio.load(html);
-
-    const jsonLdScripts = $('script[type="application/ld+json"]');
-    if (jsonLdScripts.length === 0) return null;
-
-    for (const script of jsonLdScripts.toArray()) {
-        const raw = $(script).html();
-        if (!raw) continue;
-
-        try {
-            const data = JSON.parse(raw);
-
-            // Suporte a @graph
-            const items = data['@graph'] ?? [data];
-
-            for (const item of items) {
-                const type = item['@type'];
-                if (!type) continue;
-
-                // Extrair baseado no tipo
-                const result = mapJsonLdToExtracted(item, type, url);
-                if (result) return result;
-            }
-        } catch {}
-    }
-
-    return null;
-}
-
-function mapJsonLdToExtracted(
-    data: Record<string, unknown>,
-    type: string,
-    url: string,
-): ExtractedData | null {
-    const base = {
-        source: 'json-ld' as const,
-        type,
-        url,
-        metadata: data,
-    };
-
-    if (['Article', 'NewsArticle', 'BlogPosting'].includes(type)) {
-        return {
-            ...base,
-            title: (data.headline as string) ?? '',
-            description: (data.description as string) ?? '',
-            author: (data.author as any)?.name ?? '',
-            date: (data.datePublished as string) ?? '',
-            image: Array.isArray(data.image) ? data.image[0] as string : (data.image as string) ?? '',
-            content: (data.articleBody as string) ?? '',
-        };
-    }
-
-    if (type === 'Product') {
-        return {
-            ...base,
-            title: (data.name as string) ?? '',
-            description: (data.description as string) ?? '',
-            image: Array.isArray(data.image) ? data.image[0] as string : (data.image as string) ?? '',
-            content: JSON.stringify(data.offers),
-        };
-    }
-
-    if (type === 'WebPage') {
-        return {
-            ...base,
-            title: (data.name as string) ?? '',
-            description: (data.description as string) ?? '',
-            content: '',
-        };
-    }
-
-    return null;
-}
-
-function extractFromOpenGraph(html: string, url: string): ExtractedData | null {
-    const $ = cheerio.load(html);
-
-    const title = $('meta[property="og:title"]').attr('content');
-    if (!title) return null;
-
-    return {
-        source: 'og',
-        type: 'og:article',
-        title,
-        description: $('meta[property="og:description"]').attr('content'),
-        image: $('meta[property="og:image"]').attr('content'),
-        url: $('meta[property="og:url"]').attr('content') ?? url,
-        metadata: {
-            siteName: $('meta[property="og:site_name"]').attr('content'),
-            type: $('meta[property="og:type"]').attr('content'),
-        },
-        content: '',
-    };
-}
-
-function extractFromReadability(html: string, url: string): ExtractedData | null {
-    const dom = new JSDOM(html, { url });
-    const reader = new Readability(dom.window.document);
-    const article = reader.parse();
-
-    if (!article) return null;
-
-    return {
-        source: 'readability',
-        type: 'article',
-        title: article.title,
-        author: article.byline,
-        content: article.textContent,
-        url,
-        metadata: {
-            excerpt: article.excerpt,
-            siteName: article.siteName,
-        },
-    };
-}
-
-function extractFromHtml(html: string, url: string): ExtractedData {
-    const $ = cheerio.load(html);
-
-    return {
-        source: 'html',
-        type: 'page',
-        title: $('title').text().trim() || $('h1').first().text().trim(),
-        description: $('meta[name="description"]').attr('content'),
-        author: $('meta[name="author"]').attr('content'),
-        url,
-        metadata: {},
-        content: $('body').text().replace(/\s+/g, ' ').trim(),
-    };
-}
-
-// Usar
-const data = extractWithPriority(html, 'https://example.com/article');
-if (data) {
-    console.log(`Source: ${data.source}`);
-    console.log(`Type: ${data.type}`);
-    console.log(`Title: ${data.title}`);
-}
-```
-
----
-
-## Código Completo
-
-### Exemplo 1: Content Extractor Completo
-
-```ts
-import * as cheerio from 'cheerio';
-import { Readability } from '@mozilla/readability';
-import { JSDOM } from 'jsdom';
-import TurndownService from 'turndown';
-
-interface ContentExtractorOptions {
-    url: string;
-    extractJsonLd?: boolean;
-    extractMicrodata?: boolean;
-    extractOpenGraph?: boolean;
-    extractBreadcrumbs?: boolean;
-    extractFeeds?: boolean;
-    extractReadable?: boolean;
-    htmlToMarkdown?: boolean;
-}
-
-interface ContentExtractorResult {
-    url: string;
-    title: string;
-    author?: string;
-    date?: string;
-    description?: string;
-    image?: string;
-    content: string;
-    contentMarkdown?: string;
-    breadcrumbs: Array<{ name: string; url: string }>;
-    feeds: Array<{ title: string; url: string; type: string }>;
-    openGraph: Record<string, string>;
-    jsonLd: Record<string, unknown>[];
-    metadata: Record<string, unknown>;
-}
-
-class ContentExtractor {
-    private options: ContentExtractorOptions;
-
-    constructor(options: ContentExtractorOptions) {
-        this.options = options;
-    }
-
-    async extract(html: string): Promise<ContentExtractorResult> {
-        const $ = cheerio.load(html);
-        const url = this.options.url;
-
-        const result: ContentExtractorResult = {
-            url,
-            title: $('title').text().trim(),
-            content: '',
-            breadcrumbs: [],
-            feeds: [],
-            openGraph: {},
-            jsonLd: [],
-            metadata: {},
-        };
-
-        // 1. JSON-LD
-        if (this.options.extractJsonLd) {
-            result.jsonLd = this.extractJsonLd($);
-            const article = this.findArticleInJsonLd(result.jsonLd);
-            if (article) {
-                result.title = article.headline ?? result.title;
-                result.author = article.author;
-                result.date = article.datePublished;
-                result.description = article.description;
-                result.image = article.image;
-            }
-        }
-
-        // 2. OpenGraph
-        if (this.options.extractOpenGraph) {
-            result.openGraph = this.extractOpenGraph($);
-            if (!result.description) {
-                result.description = result.openGraph['og:description'];
-            }
-            if (!result.image) {
-                result.image = result.openGraph['og:image'];
-            }
-        }
-
-        // 3. Breadcrumbs
-        if (this.options.extractBreadcrumbs) {
-            result.breadcrumbs = this.extractBreadcrumbs($);
-        }
-
-        // 4. Feeds
-        if (this.options.extractFeeds) {
-            result.feeds = this.extractFeeds($);
-        }
-
-        // 5. Readable content
-        if (this.options.extractReadable) {
-            const readable = this.extractReadable(html);
-            if (readable) {
-                result.content = readable.textContent;
-                if (!result.title || result.title === 'Untitled') {
-                    result.title = readable.title;
-                }
-                if (!result.author) {
-                    result.author = readable.byline;
-                }
-            }
-        }
-
-        // 6. HTML to Markdown
-        if (this.options.htmlToMarkdown && result.content) {
-            const turndown = new TurndownService({
-                headingStyle: 'atx',
-                codeBlockStyle: 'fenced',
-            });
-            result.contentMarkdown = turndown.turndown(result.content);
-        }
-
-        // 7. Fallback: raw content
-        if (!result.content) {
-            result.content = $('body').text().replace(/\s+/g, ' ').trim();
-        }
-
-        return result;
-    }
-
-    private extractJsonLd($: cheerio.CheerioAPI): Record<string, unknown>[] {
-        const results: Record<string, unknown>[] = [];
-
-        $('script[type="application/ld+json"]').each((_, element) => {
-            const raw = $(element).html();
-            if (!raw) return;
-
-            try {
-                const data = JSON.parse(raw);
-                if (data['@graph']) {
-                    results.push(...data['@graph']);
-                } else {
-                    results.push(data);
-                }
-            } catch {}
-        });
-
-        return results;
-    }
-
-    private findArticleInJsonLd(jsonLd: Record<string, unknown>[]): any {
-        return jsonLd.find(item =>
-            ['Article', 'NewsArticle', 'BlogPosting'].includes(item['@type'] as string)
-        );
-    }
-
-    private extractOpenGraph($: cheerio.CheerioAPI): Record<string, string> {
-        const og: Record<string, string> = {};
-
-        $('meta[property^="og:"]').each((_, element) => {
-            const property = $(element).attr('property')?.replace('og:', '');
-            const content = $(element).attr('content');
-            if (property && content) {
-                og[property] = content;
-            }
-        });
-
-        return og;
-    }
-
-    private extractBreadcrumbs($: cheerio.CheerioAPI): Array<{ name: string; url: string }> {
-        const breadcrumbs: Array<{ name: string; url: string }> = [];
-
-        $('nav[aria-label="breadcrumb"] a, .breadcrumb a').each((_, element) => {
-            const name = $(element).text().trim();
-            const url = $(element).attr('href') ?? '';
-            if (name) {
-                breadcrumbs.push({ name, url });
-            }
-        });
-
-        return breadcrumbs;
-    }
-
-    private extractFeeds($: cheerio.CheerioAPI): Array<{ title: string; url: string; type: string }> {
-        const feeds: Array<{ title: string; url: string; type: string }> = [];
-
-        $('link[type="application/rss+xml"], link[type="application/atom+xml"]').each((_, element) => {
-            const title = $(element).attr('title') ?? '';
-            const url = $(element).attr('href') ?? '';
-            const type = $(element).attr('type') ?? '';
-
-            if (url) {
-                feeds.push({ title, url, type });
-            }
-        });
-
-        return feeds;
-    }
-
-    private extractReadable(html: string): {
-        title: string;
-        content: string;
-        textContent: string;
-        byline: string;
-    } | null {
-        const dom = new JSDOM(html, { url: this.options.url });
-        const reader = new Readability(dom.window.document);
-        const article = reader.parse();
-
-        if (!article) return null;
-
-        return {
-            title: article.title,
-            content: article.content,
-            textContent: article.textContent,
-            byline: article.byline,
-        };
-    }
-}
-
-// Usar
-const extractor = new ContentExtractor({
-    url: 'https://example.com/article',
-    extractJsonLd: true,
-    extractMicrodata: true,
-    extractOpenGraph: true,
-    extractBreadcrumbs: true,
-    extractFeeds: true,
-    extractReadable: true,
-    htmlToMarkdown: true,
-});
-
-const result = await extractor.extract(html);
-console.log(`Title: ${result.title}`);
-console.log(`Author: ${result.author}`);
-console.log(`Breadcrumbs: ${result.breadcrumbs.map(b => b.name).join(' > ')}`);
-console.log(`Feeds: ${result.feeds.length}`);
-console.log(`JSON-LD items: ${result.jsonLd.length}`);
-```
-
-### Exemplo 2: Scraper com API Interception + Content Extraction
-
-```ts
-import { chromium } from 'playwright';
-import * as cheerio from 'cheerio';
-
-interface SmartScraperConfig {
-    url: string;
-    apiPatterns?: RegExp[];
-    waitFor?: number;
-    scroll?: boolean;
-}
-
-class SmartScraper {
-    private config: SmartScraperConfig;
-
-    constructor(config: SmartScraperConfig) {
-        this.config = config;
-    }
-
-    async scrape(): Promise<{
-        html: string;
-        apiData: unknown[];
-        extracted: ContentExtractorResult;
-    }> {
-        const browser = await chromium.launch();
-        const context = await browser.newContext();
-        const page = await context.newPage();
-
-        const apiData: unknown[] = [];
-
-        // Interceptar APIs se configurado
-        if (this.config.apiPatterns) {
-            page.on('response', async (response) => {
-                const url = response.url();
-                const matches = this.config.apiPatterns!.some(p => p.test(url));
-
-                if (matches) {
-                    try {
-                        const body = await response.json();
-                        apiData.push(body);
-                    } catch {}
-                }
-            });
-        }
-
-        // Navegar
-        await page.goto(this.config.url, { waitUntil: 'networkidle' });
-
-        // Scroll se configurado
-        if (this.config.scroll) {
-            await page.evaluate(async () => {
-                await new Promise(resolve => {
-                    let totalHeight = 0;
-                    const distance = 500;
-                    const timer = setInterval(() => {
-                        window.scrollBy(0, distance);
-                        totalHeight += distance;
-                        if (totalHeight >= document.body.scrollHeight) {
-                            clearInterval(timer);
-                            resolve(undefined);
-                        }
-                    }, 200);
-                });
-            });
-        }
-
-        // Aguardar se configurado
-        if (this.config.waitFor) {
-            await page.waitForTimeout(this.config.waitFor);
-        }
-
-        // Extrair HTML
-        const html = await page.content();
-        await browser.close();
-
-        // Extrair conteúdo
-        const extractor = new ContentExtractor({
-            url: this.config.url,
-            extractJsonLd: true,
-            extractOpenGraph: true,
-            extractBreadcrumbs: true,
-            extractReadable: true,
-            htmlToMarkdown: true,
-        });
-
-        const extracted = await extractor.extract(html);
-
-        return { html, apiData, extracted };
-    }
-}
-
-// Usar
-const scraper = new SmartScraper({
-    url: 'https://example.com/products',
-    apiPatterns: [/\/api\/products/],
-    scroll: true,
-    waitFor: 2000,
-});
-
-const result = await scraper.scrape();
-console.log(`HTML length: ${result.html.length}`);
-console.log(`API calls intercepted: ${result.apiData.length}`);
-console.log(`Title: ${result.extracted.title}`);
-console.log(`Content length: ${result.extracted.content.length}`);
-```
-
-### Exemplo 3: Batch Extraction com Cache
-
-```ts
-import { LRUCache } from 'lru-cache';
-import { ContentExtractor, ContentExtractorResult } from './content-extractor';
-
-class BatchExtractor {
-    private cache: LRUCache<string, ContentExtractorResult>;
-    private extractor: ContentExtractor;
-
-    constructor(options: { cacheSize?: number; cacheTtl?: number } = {}) {
-        this.cache = new LRUCache({
-            max: options.cacheSize ?? 1000,
-            ttl: options.cacheTtl ?? 1000 * 60 * 30, // 30 min
-        });
-
-        this.extractor = new ContentExtractor({
-            url: '',
-            extractJsonLd: true,
-            extractOpenGraph: true,
-            extractReadable: true,
-            htmlToMarkdown: true,
-        });
-    }
-
-    async extract(url: string, html: string): Promise<ContentExtractorResult> {
-        const cached = this.cache.get(url);
-        if (cached) {
-            console.log(`Cache HIT: ${url}`);
-            return cached;
-        }
-
-        console.log(`Cache MISS: ${url}`);
-        this.extractor = new ContentExtractor({ url, extractJsonLd: true, extractOpenGraph: true, extractReadable: true, htmlToMarkdown: true });
-        const result = await this.extractor.extract(html);
-
-        this.cache.set(url, result);
-        return result;
-    }
-
-    async extractBatch(
-        items: Array<{ url: string; html: string }>,
-    ): Promise<ContentExtractorResult[]> {
-        const results: ContentExtractorResult[] = [];
-
-        for (const item of items) {
-            const result = await this.extract(item.url, item.html);
-            results.push(result);
-        }
-
-        return results;
-    }
-
-    stats(): { size: number } {
-        return { size: this.cache.size };
-    }
-}
-
-// Usar
-const batchExtractor = new BatchExtractor({ cacheSize: 5000 });
-
-const results = await batchExtractor.extractBatch([
-    { url: 'https://example.com/page1', html: html1 },
-    { url: 'https://example.com/page2', html: html2 },
-    { url: 'https://example.com/page1', html: html1 }, // Cache HIT
-]);
-
-console.log(`Cache stats:`, batchExtractor.stats());
-```
-
----
-
-## Referências
-
-- [Schema.org](https://schema.org)
-- [JSON-LD Specification](https://www.w3.org/TR/json-ld/)
-- [OpenGraph Protocol](https://ogp.me/)
-- [Twitter Card Documentation](https://developer.twitter.com/en/docs/twitter-for-websites/cards/overview/abouts-cards)
-- [@mozilla/readability npm](https://www.npmjs.com/package/@mozilla/readability)
-- [turndown npm](https://www.npmjs.com/package/turndown)
-- [node-html-markdown npm](https://www.npmjs.com/package/node-html-markdown)
-- [mdream npm](https://www.npmjs.com/package/mdream)
-- [open-graph-scraper npm](https://www.npmjs.com/package/open-graph-scraper)
-- [feedsmith npm](https://www.npmjs.com/package/feedsmith)
-- [rss-parser npm](https://www.npmjs.com/package/rss-parser)
-- [rss-finder npm](https://www.npmjs.com/package/rss-finder)
-- [Cheerio Documentation](https://cheerio.js.org/)
-- [Playwright Network Interception](https://playwright.dev/docs/network)