recker 1.0.43 → 1.0.44-next.084c2ef

package/dist/browser/seo/analyzer.js

@@ -0,0 +1,1399 @@
+import { parse } from '../scrape/parser/index.js';
+import { extractMeta, extractOpenGraph, extractTwitterCard, extractJsonLd, extractLinks, extractImages, } from '../scrape/extractors.js';
+import { generateKeywordCloud } from './keywords.js';
+import { createRulesEngine, SEO_THRESHOLDS, } from './rules/index.js';
+export class SeoAnalyzer {
+    root;
+    options;
+    rulesEngine;
+    constructor(root, options = {}) {
+        this.root = root;
+        this.options = options;
+        this.rulesEngine = createRulesEngine(options.rules);
+    }
+    static async fromHtml(html, options = {}) {
+        const root = parse(html);
+        return new SeoAnalyzer(root, options);
+    }
+    analyze() {
+        const url = this.options.baseUrl || '';
+        const meta = extractMeta(this.root);
+        const og = extractOpenGraph(this.root);
+        const twitter = extractTwitterCard(this.root);
+        const jsonLd = extractJsonLd(this.root);
+        const links = extractLinks(this.root, { baseUrl: this.options.baseUrl });
+        const images = extractImages(this.root, { baseUrl: this.options.baseUrl });
+        const visibleText = this.getVisibleText();
+        const keywords = generateKeywordCloud({
+            visibleText,
+            title: meta.title,
+            description: meta.description,
+            keywords: meta.keywords?.join(', ')
+        });
+        const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+        const emailsFound = (visibleText.match(emailRegex) || []).filter(e => !e.endsWith('.png') && !e.endsWith('.jpg') && !e.endsWith('.webp'));
+        const socialDomains = ['facebook.com', 'twitter.com', 'x.com', 'instagram.com', 'linkedin.com', 'youtube.com', 'pinterest.com', 'tiktok.com', 'github.com', 'reddit.com', 'snapchat.com', 'whatsapp.com', 'telegram.org', 'discord.com', 'threads.net'];
+        const socialLinksFound = links
+            .map(l => l.href)
+            .filter(href => socialDomains.some(d => href.toLowerCase().includes(d)));
+        const socialLinkDetails = this.analyzeSocialLinks(links, socialDomains);
+        const headings = this.analyzeHeadings();
+        const content = this.analyzeContent(headings);
+        const linkAnalysis = this.buildLinkAnalysis(links);
+        const imageAnalysis = this.buildImageAnalysis(images);
+        const social = this.buildSocialAnalysis(og, twitter);
+        const technical = this.buildTechnicalAnalysis(meta);
+        const resources = this.analyzeResources();
+        const analytics = this.analyzeAnalytics();
+        const feeds = this.analyzeFeeds();
+        const conversion = this.analyzeConversionElements(links, visibleText);
+        const context = this.buildRuleContext({
+            meta,
+            og,
+            twitter,
+            jsonLd,
+            headings,
+            content,
+            linkAnalysis,
+            imageAnalysis,
+            links,
+            keywords,
+            resources,
+            emailsFound,
+            socialLinksFound,
+            socialLinkDetails,
+            analytics,
+            feeds,
+            conversion,
+        });
+        const ruleResults = this.rulesEngine.evaluate(context);
+        const checks = this.convertToCheckResults(ruleResults);
+        const { score, grade } = this.calculateScore(checks);
+        const summary = this.buildSummary(ruleResults, checks, {
+            content,
+            imageAnalysis,
+            linkAnalysis,
+            meta,
+            og,
+            twitter,
+            technical,
+        });
+        return {
+            url,
+            timestamp: new Date(),
+            grade,
+            score,
+            summary,
+            checks,
+            title: meta.title
+                ? { text: meta.title, length: meta.title.length }
+                : undefined,
+            metaDescription: meta.description
+                ? { text: meta.description, length: meta.description.length }
+                : undefined,
+            openGraph: Object.keys(og).length > 0
+                ? {
+                    title: og.title,
+                    description: og.description,
+                    image: Array.isArray(og.image) ? og.image[0] : og.image,
+                    url: og.url,
+                    type: og.type,
+                    siteName: og.siteName,
+                }
+                : undefined,
+            twitterCard: Object.keys(twitter).length > 0
+                ? {
+                    card: twitter.card,
+                    title: twitter.title,
+                    description: twitter.description,
+                    image: Array.isArray(twitter.image)
+                        ? twitter.image[0]
+                        : twitter.image,
+                    site: twitter.site,
+                }
+                : undefined,
+            structuredData: {
+                count: jsonLd.length,
+                types: jsonLd.map((j) => j['@type']).filter(Boolean),
+                items: jsonLd,
+            },
+            headings: headings,
+            content,
+            keywords,
+            links: linkAnalysis,
+            images: imageAnalysis,
+            social,
+            technical,
+        };
+    }
+    getMainBody() {
+        const bodies = this.root.querySelectorAll('body');
+        if (bodies.length === 0)
+            return null;
+        if (bodies.length === 1)
+            return bodies[0];
+        return bodies.reduce((prev, curr) => curr.text.length > prev.text.length ? curr : prev);
+    }
+    getVisibleText() {
+        const body = this.getMainBody();
+        if (!body)
+            return '';
+        const clone = body.clone();
+        const tagsToRemove = ['script', 'style', 'noscript', 'iframe', 'svg', 'header', 'footer', 'nav'];
+        try {
+            const elements = clone.querySelectorAll(tagsToRemove.join(','));
+            elements.forEach(el => el.remove());
+        }
+        catch {
+            tagsToRemove.forEach(tag => {
+                clone.querySelectorAll(tag).forEach(el => el.remove());
+            });
+        }
+        return clone.text.replace(/\s+/g, ' ').trim();
+    }
+    buildRuleContext(data) {
+        const { meta, og, twitter, jsonLd, headings, content, linkAnalysis, imageAnalysis, links, keywords, resources, emailsFound, socialLinksFound, socialLinkDetails, analytics, feeds, conversion, } = data;
+        const html = this.root.querySelector('html');
+        const htmlLang = html ? html.getAttribute('lang') : undefined;
+        const hreflangTags = [];
+        this.root
+            .querySelectorAll('link[rel="alternate"][hreflang]')
+            .forEach((el) => {
+            const lang = el.getAttribute('hreflang');
+            const href = el.getAttribute('href');
+            if (lang && href) {
+                hreflangTags.push({ lang, href });
+            }
+        });
+        const ogLocaleEl = this.root.querySelector('meta[property="og:locale"]');
+        const ogLocale = ogLocaleEl ? ogLocaleEl.getAttribute('content') : undefined;
+        const genericTexts = SEO_THRESHOLDS.links.genericTexts;
+        const genericTextLinks = links.filter((l) => {
+            const text = l.text?.toLowerCase().trim();
+            return text && genericTexts.some((g) => text === g || text.includes(g));
+        });
+        const linksWithGenericText = genericTextLinks.length;
+        const linksWithoutTextArray = links.filter((l) => {
+            const hasText = l.text && l.text.trim() !== '';
+            const hasContent = l.hasImageWithAlt || l.hasSvgWithTitle;
+            const hasA11yLabel = l.ariaLabel || l.title;
+            return !hasText && !hasContent && !hasA11yLabel;
+        });
+        const externalBlankLinks = links.filter((l) => l.type === 'external' && l.target === '_blank');
+        const missingNoopenerLinks = externalBlankLinks.filter((l) => !l.rel?.includes('noopener'));
+        const missingNoreferrerLinks = externalBlankLinks.filter((l) => !l.rel?.includes('noreferrer'));
+        const problematicLinks = {
+            withoutText: linksWithoutTextArray,
+            genericText: genericTextLinks,
+            missingNoopener: missingNoopenerLinks,
+            missingNoreferrer: missingNoreferrerLinks,
+        };
+        const hasMixedContent = this.checkMixedContent();
+        const h1Elements = this.root.querySelectorAll('h1');
+        const h1Text = h1Elements.length > 0 ? h1Elements[0].text.trim() : '';
+        const iframeCount = this.root.querySelectorAll('iframe').length;
+        const topKeywords = keywords.topKeywords.slice(0, 5).map(k => k.word);
+        const mainKeyword = topKeywords.length > 0 ? topKeywords[0] : undefined;
+        const keywordsInTitle = topKeywords.some(kw => meta.title?.toLowerCase().includes(kw));
+        const keywordsInDescription = topKeywords.some(kw => meta.description?.toLowerCase().includes(kw));
+        const keywordsInH1 = topKeywords.some(kw => h1Text.toLowerCase().includes(kw));
+        const urlPath = this.options.baseUrl ? new URL(this.options.baseUrl).pathname.toLowerCase().replace(/[-_]/g, ' ') : '';
+        const keywordsInUrl = topKeywords.some(kw => urlPath.includes(kw));
+        const firstParagraph = this.root.querySelector('p')?.text?.toLowerCase() || '';
+        const keywordsInFirstParagraph = topKeywords.some(kw => firstParagraph.includes(kw));
+        const imageAlts = imageAnalysis.imageAltTexts || [];
+        const keywordsInAltText = imageAlts.some(alt => topKeywords.some(kw => alt.includes(kw)));
+        const keywordConsistencyDetails = mainKeyword ? {
+            inTitle: meta.title?.toLowerCase().includes(mainKeyword) || false,
+            inDescription: meta.description?.toLowerCase().includes(mainKeyword) || false,
+            inH1: h1Text.toLowerCase().includes(mainKeyword) || false,
+            inUrl: urlPath.includes(mainKeyword),
+            inFirstParagraph: firstParagraph.includes(mainKeyword),
+            inAltText: imageAlts.some(alt => alt.includes(mainKeyword)),
+        } : undefined;
+        const keywordConsistencyScore = keywordConsistencyDetails
+            ? Object.values(keywordConsistencyDetails).filter(Boolean).length
+            : undefined;
+        const viewportEl = this.root.querySelector('meta[name="viewport"]');
+        const viewportContent = viewportEl
+            ? viewportEl.getAttribute('content')
+            : undefined;
+        const a11yMetrics = this.analyzeAccessibility();
+        const imagesWithEmptyAlt = this.root.querySelectorAll('img[alt=""]').length;
+        const linkSecurityMetrics = this.analyzeLinkSecurity();
+        const faviconInfo = this.detectFavicon();
+        const perfHints = this.analyzePerformanceHints();
+        const cwvHints = this.analyzeCWVHints();
+        const structuralHtml = this.analyzeStructuralHtml();
+        const breadcrumbs = this.analyzeBreadcrumbs(jsonLd.map((j) => j['@type']).filter(Boolean));
+        const multimedia = this.analyzeMultimedia();
+        const advancedImages = this.analyzeAdvancedImages();
+        const responsiveImages = this.analyzeResponsiveImages();
+        const inlineImages = this.analyzeInlineImages();
+        const trustSignals = this.analyzeTrustSignals(links);
+        const totalSubheadings = (headings.structure.filter((h) => h.level === 2).length || 0) +
+            (headings.structure.filter((h) => h.level === 3).length || 0);
+        const subheadingFrequency = content.wordCount > 0
+            ? (totalSubheadings / content.wordCount) * 100
+            : 0;
+        const textHtmlRatio = this.calculateTextHtmlRatio(content.characterCount);
+        return {
+            jsFilesCount: resources.jsFilesCount,
+            cssFilesCount: resources.cssFilesCount,
+            unminifiedResources: resources.unminifiedResources,
+            unminifiedResourceUrls: resources.unminifiedResourceUrls,
+            emailsFound,
+            socialLinksFound,
+            ...socialLinkDetails,
+            keywordsInTitle,
+            keywordsInDescription,
+            keywordsInH1,
+            keywordsInUrl,
+            keywordsInFirstParagraph,
+            keywordsInAltText,
+            keywordConsistencyScore,
+            keywordConsistencyDetails,
+            topKeywords,
+            mainKeyword,
+            title: meta.title,
+            titleLength: meta.title?.length,
+            metaDescription: meta.description,
+            metaDescriptionLength: meta.description?.length,
+            metaKeywords: meta.keywords,
+            metaRobots: meta.robots,
+            ogTitle: og.title,
+            ogDescription: og.description,
+            ogImage: Array.isArray(og.image) ? og.image[0] : og.image,
+            ogUrl: og.url,
+            ogType: og.type,
+            ogSiteName: og.siteName,
+            twitterCard: twitter.card,
+            twitterTitle: twitter.title,
+            twitterDescription: twitter.description,
+            twitterImage: Array.isArray(twitter.image)
+                ? twitter.image[0]
+                : twitter.image,
+            twitterSite: twitter.site,
+            h1Count: headings.h1Count,
+            h1Text: h1Text || undefined,
+            h1Length: h1Text?.length,
+            h2Count: headings.structure.filter((h) => h.level === 2).length,
+            headingHierarchyValid: headings.hasProperHierarchy,
+            headingSkippedLevels: headings.issues.filter((i) => i.includes('Skipped')),
+            sectionWordCounts: headings.sectionWordCounts,
+            totalImages: imageAnalysis.total,
+            imagesWithAlt: imageAnalysis.withAlt,
+            imagesWithoutAlt: imageAnalysis.withoutAlt,
+            imagesWithLazyLoad: imageAnalysis.lazy,
+            imagesMissingDimensions: imageAnalysis.missingDimensions,
+            imagesWithEmptyAlt,
+            imagesUsingModernFormats: imageAnalysis.modernFormats,
+            altTextLengths: imageAnalysis.altTextLengths,
+            imageAltTexts: imageAnalysis.imageAltTexts,
+            imageFilenames: imageAnalysis.imageFilenames,
+            imagesWithAsyncDecoding: imageAnalysis.imagesWithAsyncDecoding,
+            imagesWithSrcset: responsiveImages.imagesWithSrcset,
+            largeBase64ImagesCount: inlineImages.largeBase64ImagesCount,
+            ...a11yMetrics,
+            allLinks: links,
+            totalLinks: linkAnalysis.total,
+            internalLinks: linkAnalysis.internal,
+            externalLinks: linkAnalysis.external,
+            internalHttpLinks: linkAnalysis.internalHttpLinks,
+            internalHttpLinkUrls: linkAnalysis.internalHttpLinkUrls,
+            linksWithoutText: linkAnalysis.withoutText,
+            nofollowLinks: linkAnalysis.nofollow,
+            sponsoredLinks: linkAnalysis.sponsoredLinks,
+            ugcLinks: linkAnalysis.ugcLinks,
+            linksWithGenericText,
+            ...linkSecurityMetrics,
+            problematicLinks,
+            wordCount: content.wordCount,
+            characterCount: content.characterCount,
+            sentenceCount: content.sentenceCount,
+            paragraphCount: content.paragraphCount,
+            avgWordsPerSentence: content.avgWordsPerSentence,
+            avgParagraphLength: content.avgParagraphLength,
+            listCount: content.listCount,
+            strongTagCount: content.strongTagCount,
+            emTagCount: content.emTagCount,
+            subheadingFrequency,
+            paragraphWordCounts: content.paragraphWordCounts,
+            avgSentenceLength: content.avgSentenceLength,
+            faqCount: content.faqCount,
+            imagePerWordRatio: content.imagePerWordRatio,
+            keywordDensity: content.keywordDensity,
+            fleschReadingEase: content.fleschReadingEase,
+            hasQuestionHeadings: content.hasQuestionHeadings,
+            ...structuralHtml,
+            ...trustSignals,
+            ...breadcrumbs,
+            ...multimedia,
+            hasCanonical: !!meta.canonical,
+            canonicalUrl: meta.canonical,
+            hasViewport: !!meta.viewport,
+            viewportContent,
+            hasCharset: !!meta.charset,
+            charset: meta.charset,
+            hasLang: !!htmlLang,
+            langValue: htmlLang,
+            isHttps: this.options.baseUrl?.startsWith('https://'),
+            hasMixedContent,
+            responseHeaders: this.options.responseHeaders,
+            textHtmlRatio,
+            hasFrameTags: this.root.querySelectorAll('frame, frameset').length > 0,
+            iframeCount: this.root.querySelectorAll('iframe').length,
+            hasDeprecatedPlugins: this.root.querySelectorAll('object, embed, applet').length > 0,
+            deprecatedTagsCount: this.root.querySelectorAll('center, font, strike, u, marquee, blink, big, tt').length,
+            deprecatedTagsFound: ['center', 'font', 'strike', 'u', 'marquee', 'blink', 'big', 'tt'].filter(t => this.root.querySelectorAll(t).length > 0),
+            hasAppleTouchIcon: this.root.querySelectorAll('link[rel="apple-touch-icon"], link[rel="apple-touch-icon-precomposed"]').length > 0,
+            ...faviconInfo,
+            ...perfHints,
+            lcpHints: cwvHints.lcpHints,
+            clsHints: cwvHints.clsHints,
+            jsonLdCount: jsonLd.length,
+            jsonLdTypes: jsonLd.map((j) => j['@type']).filter(Boolean),
+            url: this.options.baseUrl,
+            urlLength: this.options.baseUrl?.length,
+            titleMatchesH1: meta.title && h1Text
+                ? meta.title.toLowerCase().trim() === h1Text.toLowerCase().trim()
+                : undefined,
+            ...this.analyzeUrlQuality(),
+            ...this.analyzeJsRendering(content),
+            hreflangTags: hreflangTags.length > 0 ? hreflangTags : undefined,
+            ogLocale,
+            analyticsDetected: analytics.analyticsDetected,
+            analyticsProviders: analytics.analyticsProviders,
+            ...feeds,
+            ctaButtonsCount: conversion.ctaButtonsCount,
+            formCount: conversion.formCount,
+            hasWhatsAppLink: conversion.hasWhatsAppLink,
+            hasPhoneOnPage: conversion.hasPhoneOnPage,
+        };
+    }
+    analyzeUrlQuality() {
+        if (!this.options.baseUrl) {
+            return {
+                urlHasUppercase: false,
+                urlHasSpecialChars: false,
+                urlHasAccents: false,
+            };
+        }
+        try {
+            const url = new URL(this.options.baseUrl);
+            const path = url.pathname + url.search;
+            const urlHasUppercase = /[A-Z]/.test(path);
+            const urlHasAccents = /[àáâãäåæçèéêëìíîïñòóôõöùúûüýÿ]/i.test(path);
+            const urlHasSpecialChars = /[<>{}|\^`\[\]]/.test(path) || /%[0-9A-F]{2}/i.test(path);
+            return { urlHasUppercase, urlHasSpecialChars, urlHasAccents };
+        }
+        catch {
+            return {
+                urlHasUppercase: false,
+                urlHasSpecialChars: false,
+                urlHasAccents: false,
+            };
+        }
+    }
+    analyzeJsRendering(content) {
+        const bodyTextLength = content.characterCount;
+        const scriptCount = this.root.querySelectorAll('script').length;
+        const noscriptEl = this.root.querySelector('noscript');
+        const noscriptContent = noscriptEl ? noscriptEl.text.trim() : '';
+        const hasNoscriptContent = noscriptContent.length > 0;
+        return { bodyTextLength, scriptCount, hasNoscriptContent };
+    }
+    analyzeResponsiveImages() {
+        let imagesWithSrcset = 0;
+        this.root.querySelectorAll('img').forEach((img) => {
+            if (img.getAttribute('srcset') || (img.parentNode && img.parentNode.tagName === 'PICTURE')) {
+                imagesWithSrcset++;
+            }
+        });
+        return { imagesWithSrcset };
+    }
+    analyzeInlineImages() {
+        let largeBase64ImagesCount = 0;
+        this.root.querySelectorAll('img').forEach((img) => {
+            const src = img.getAttribute('src') || '';
+            if (src.startsWith('data:image') && src.length > 5 * 1024) {
+                largeBase64ImagesCount++;
+            }
+        });
+        return { largeBase64ImagesCount };
+    }
+    checkMixedContent() {
+        let hasMixed = false;
+        this.root.querySelectorAll('img[src^="http://"]').forEach(() => {
+            hasMixed = true;
+        });
+        this.root.querySelectorAll('script[src^="http://"]').forEach(() => {
+            hasMixed = true;
+        });
+        this.root.querySelectorAll('link[href^="http://"]').forEach(() => {
+            hasMixed = true;
+        });
+        return hasMixed;
+    }
+    analyzeLinkSecurity() {
+        let withoutNoopener = 0;
+        let withoutNoreferrer = 0;
+        this.root
+            .querySelectorAll('a[href^="http"][target="_blank"]')
+            .forEach((el) => {
+            const href = el.getAttribute('href') || '';
+            const rel = (el.getAttribute('rel') || '').toLowerCase();
+            if (this.options.baseUrl && href.startsWith(this.options.baseUrl)) {
+                return;
+            }
+            if (!rel.includes('noopener')) {
+                withoutNoopener++;
+            }
+            if (!rel.includes('noreferrer')) {
+                withoutNoreferrer++;
+            }
+        });
+        return {
+            externalLinksWithoutNoopener: withoutNoopener,
+            externalLinksWithoutNoreferrer: withoutNoreferrer,
+        };
+    }
+    detectFavicon() {
+        const faviconSelectors = [
+            'link[rel="icon"]',
+            'link[rel="shortcut icon"]',
+            'link[rel="apple-touch-icon"]',
+            'link[rel="apple-touch-icon-precomposed"]',
+        ];
+        for (const selector of faviconSelectors) {
+            const favicon = this.root.querySelector(selector);
+            if (favicon) {
+                return {
+                    hasFavicon: true,
+                    faviconUrl: favicon.getAttribute('href'),
+                };
+            }
+        }
+        return { hasFavicon: false };
+    }
+    analyzePerformanceHints() {
+        const preconnectLinks = this.root.querySelectorAll('link[rel="preconnect"]');
+        const preconnectCount = preconnectLinks.length;
+        const dnsPrefetchLinks = this.root.querySelectorAll('link[rel="dns-prefetch"]');
+        const dnsPrefetchCount = dnsPrefetchLinks.length;
+        const preloadLinks = this.root.querySelectorAll('link[rel="preload"]');
+        const preloadCount = preloadLinks.length;
+        let renderBlockingResources = 0;
+        this.root
+            .querySelectorAll('head script[src]:not([async]):not([defer])')
+            .forEach(() => {
+            renderBlockingResources++;
+        });
+        this.root.querySelectorAll('head link[rel="stylesheet"]').forEach((el) => {
+            const media = el.getAttribute('media');
+            if (!media || media === 'all' || media === 'screen') {
+                renderBlockingResources++;
+            }
+        });
+        const inlineScriptsCount = this.root
+            .querySelectorAll('script:not([src])')
+            .filter((el) => {
+            const content = el.innerHTML || '';
+            return content.trim().length > 0;
+        }).length;
+        const inlineStylesCount = this.root.querySelectorAll('style').length;
+        return {
+            hasPreconnect: preconnectCount > 0,
+            preconnectCount,
+            hasDnsPrefetch: dnsPrefetchCount > 0,
+            dnsPrefetchCount,
+            hasPreload: preloadCount > 0,
+            preloadCount,
+            renderBlockingResources,
+            inlineScriptsCount,
+            inlineStylesCount,
+        };
+    }
+    analyzeCWVHints() {
+        const images = this.root.querySelectorAll('img');
+        let hasLargeImages = false;
+        let hasLazyLcp = false;
+        let hasPriorityHints = false;
+        images.slice(0, 3).forEach((el, index) => {
+            const width = parseInt(el.getAttribute('width') || '0', 10);
+            const height = parseInt(el.getAttribute('height') || '0', 10);
+            const loading = el.getAttribute('loading');
+            const fetchPriority = el.getAttribute('fetchpriority');
+            if (width >= 400 || height >= 300) {
+                hasLargeImages = true;
+            }
+            if (index === 0 && loading === 'lazy') {
+                hasLazyLcp = true;
+            }
+            if (fetchPriority === 'high') {
+                hasPriorityHints = true;
+            }
+        });
+        this.root
+            .querySelectorAll('[style*="background-image"]')
+            .slice(0, 3)
+            .forEach(() => {
+            hasLargeImages = true;
+        });
+        const imagesWithoutDimensions = this.root.querySelectorAll('img:not([width]):not([height])').length +
+            this.root.querySelectorAll('img[width="auto"], img[height="auto"]')
+                .length;
+        return {
+            lcpHints: {
+                hasLargeImages,
+                hasLazyLcp,
+                hasPriorityHints,
+            },
+            clsHints: {
+                imagesWithoutDimensions,
+            },
+        };
+    }
+    analyzeAccessibility() {
+        let buttonsWithoutAriaLabel = 0;
+        this.root.querySelectorAll('button').forEach((el) => {
+            const text = el.text.trim();
+            const ariaLabel = el.getAttribute('aria-label');
+            const ariaLabelledBy = el.getAttribute('aria-labelledby');
+            const title = el.getAttribute('title');
+            if (!text && !ariaLabel && !ariaLabelledBy && !title) {
+                buttonsWithoutAriaLabel++;
+            }
+        });
+        let linksWithoutAriaLabel = 0;
+        this.root.querySelectorAll('a[href]').forEach((el) => {
+            const text = el.text.trim();
+            const ariaLabel = el.getAttribute('aria-label');
+            const ariaLabelledBy = el.getAttribute('aria-labelledby');
+            const title = el.getAttribute('title');
+            const imgs = el.querySelectorAll('img');
+            const hasImgWithAlt = imgs.filter((img) => !!img.getAttribute('alt')?.trim()).length > 0;
+            const svgs = el.querySelectorAll('svg');
+            const hasSvgWithTitle = svgs.filter((svg) => svg.querySelectorAll('title').length > 0 ||
+                !!svg.getAttribute('aria-label')).length > 0;
+            const hasContent = text || hasImgWithAlt || hasSvgWithTitle;
+            const hasLabel = ariaLabel || ariaLabelledBy || title;
+            if (!hasContent && !hasLabel) {
+                linksWithoutAriaLabel++;
+            }
+        });
+        let inputsWithoutLabel = 0;
+        this.root
+            .querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="reset"]), select, textarea')
+            .forEach((el) => {
+            const id = el.getAttribute('id');
+            const ariaLabel = el.getAttribute('aria-label');
+            const ariaLabelledBy = el.getAttribute('aria-labelledby');
+            const placeholder = el.getAttribute('placeholder');
+            const title = el.getAttribute('title');
+            const hasLabel = id
+                ? this.root.querySelectorAll(`label[for="${id}"]`).length > 0
+                : false;
+            const wrappedInLabel = el.closest('label') !== null;
+            if (!hasLabel &&
+                !wrappedInLabel &&
+                !ariaLabel &&
+                !ariaLabelledBy &&
+                !title &&
+                !placeholder) {
+                inputsWithoutLabel++;
+            }
+        });
+        const iframesWithoutTitle = this.root.querySelectorAll('iframe:not([title])').length;
+        let tablesWithoutCaption = 0;
+        this.root.querySelectorAll('table').forEach((el) => {
+            const hasCaption = el.querySelectorAll('caption').length > 0;
+            const ariaLabel = el.getAttribute('aria-label');
+            const ariaLabelledBy = el.getAttribute('aria-labelledby');
+            const role = el.getAttribute('role');
+            if (role === 'presentation' || role === 'none')
+                return;
+            const hasHeaders = el.querySelectorAll('th').length > 0;
+            if (hasHeaders && !hasCaption && !ariaLabel && !ariaLabelledBy) {
+                tablesWithoutCaption++;
+            }
+        });
+        let svgsWithoutTitle = 0;
+        this.root.querySelectorAll('svg').forEach((el) => {
+            const hasTitle = el.querySelectorAll('title').length > 0;
+            const ariaLabel = el.getAttribute('aria-label');
+            const ariaLabelledBy = el.getAttribute('aria-labelledby');
+            const ariaHidden = el.getAttribute('aria-hidden');
+            const role = el.getAttribute('role');
+            if (ariaHidden === 'true' || role === 'presentation' || role === 'none')
+                return;
+            if (!hasTitle && !ariaLabel && !ariaLabelledBy) {
+                svgsWithoutTitle++;
+            }
+        });
+        return {
+            buttonsWithoutAriaLabel,
+            linksWithoutAriaLabel,
+            inputsWithoutLabel,
+            iframesWithoutTitle,
+            tablesWithoutCaption,
+            svgsWithoutTitle,
+        };
+    }
+    analyzeStructuralHtml() {
+        return {
+            hasHeader: this.root.querySelectorAll('header').length > 0,
+            hasNav: this.root.querySelectorAll('nav').length > 0,
+            hasMain: this.root.querySelectorAll('main').length > 0,
+            hasArticle: this.root.querySelectorAll('article').length > 0,
+            hasSection: this.root.querySelectorAll('section').length > 0,
+            hasFooter: this.root.querySelectorAll('footer').length > 0,
+        };
+    }
+    analyzeBreadcrumbs(jsonLdTypes) {
+        const hasBreadcrumbsHtml = this.root.querySelectorAll('nav[aria-label="breadcrumb"], .breadcrumb, .breadcrumbs').length > 0;
+        const hasBreadcrumbsSchema = jsonLdTypes.includes('BreadcrumbList');
+        return { hasBreadcrumbsHtml, hasBreadcrumbsSchema };
+    }
+    analyzeMultimedia() {
+        const videos = this.root.querySelectorAll('video');
+        const audios = this.root.querySelectorAll('audio');
+        let hasAutoplay = false;
+        const checkAutoplay = (list) => {
+            list.forEach(el => {
+                if (el.getAttribute('autoplay') !== undefined || el.hasAttribute('autoplay')) {
+                    hasAutoplay = true;
+                }
+            });
+        };
+        checkAutoplay(videos);
+        checkAutoplay(audios);
+        return {
+            videoCount: videos.length,
+            audioCount: audios.length,
+            hasAutoplay
+        };
+    }
+    analyzeSocialLinks(links, socialDomains) {
+        const socialLinks = links.filter(l => socialDomains.some(d => l.href.toLowerCase().includes(d)));
+        const platformMap = {
+            'facebook.com': 'facebook',
+            'twitter.com': 'twitter',
+            'x.com': 'twitter',
+            'instagram.com': 'instagram',
+            'linkedin.com': 'linkedin',
+            'youtube.com': 'youtube',
+            'pinterest.com': 'pinterest',
+            'tiktok.com': 'tiktok',
+            'github.com': 'github',
+            'reddit.com': 'reddit',
+            'snapchat.com': 'snapchat',
+            'whatsapp.com': 'whatsapp',
+            'telegram.org': 'telegram',
+            'discord.com': 'discord',
+            'threads.net': 'threads',
+        };
+        const socialLinkDetails = [];
+        let socialLinksInHeader = 0;
+        let socialLinksInFooter = 0;
+        let socialLinksWithoutAccessibility = 0;
+        let socialLinksWithoutNewTab = 0;
+        let socialLinksWithoutNoopener = 0;
+        const platformsFound = new Set();
+        const headerLinks = this.root.querySelectorAll('header a[href]');
+        const footerLinks = this.root.querySelectorAll('footer a[href]');
+        const headerHrefs = new Set(headerLinks.map(l => l.getAttribute('href') || ''));
+        const footerHrefs = new Set(footerLinks.map(l => l.getAttribute('href') || ''));
+        for (const link of socialLinks) {
+            let platform = 'unknown';
+            for (const [domain, name] of Object.entries(platformMap)) {
+                if (link.href.toLowerCase().includes(domain)) {
+                    platform = name;
+                    platformsFound.add(name);
+                    break;
+                }
+            }
+            let location = 'body';
+            if (headerHrefs.has(link.href)) {
+                location = 'header';
+                socialLinksInHeader++;
+            }
+            else if (footerHrefs.has(link.href)) {
+                location = 'footer';
+                socialLinksInFooter++;
+            }
+            const hasAccessibility = !!(link.ariaLabel || link.title || (link.text && link.text.trim()));
+            if (!hasAccessibility) {
+                socialLinksWithoutAccessibility++;
+            }
+            const hasNewTab = link.target === '_blank';
+            if (!hasNewTab) {
+                socialLinksWithoutNewTab++;
+            }
+            const hasNoopener = !!(link.rel && link.rel.includes('noopener'));
+            if (hasNewTab && !hasNoopener) {
+                socialLinksWithoutNoopener++;
+            }
+            socialLinkDetails.push({
+                href: link.href,
+                platform,
+                hasAccessibility,
+                hasNewTab,
+                hasNoopener,
+                location,
+            });
+        }
+        return {
+            totalSocialLinks: socialLinks.length,
+            socialLinksInHeader,
+            socialLinksInFooter,
+            socialLinksWithoutAccessibility,
+            socialLinksWithoutNewTab,
+            socialLinksWithoutNoopener,
+            platformsFound: Array.from(platformsFound),
+            socialLinkDetails,
+        };
+    }
+    analyzeTrustSignals(links) {
+        const linkHrefs = links.map((l) => l.href.toLowerCase());
+        return {
+            hasAboutPageLink: linkHrefs.some((href) => href.includes('about') || href.includes('quem-somos')),
+            hasContactPageLink: linkHrefs.some((href) => href.includes('contact') || href.includes('contato')),
+            hasPrivacyPolicyLink: linkHrefs.some((href) => href.includes('privacy') || href.includes('privacidade')),
+            hasTermsOfServiceLink: linkHrefs.some((href) => href.includes('terms') || href.includes('termos-de-uso')),
+        };
+    }
+    analyzeAnalytics() {
+        const providers = [];
+        const html = this.root.innerHTML || '';
+        const scripts = this.root.querySelectorAll('script');
+        const scriptSources = [];
+        const scriptContents = [];
+        scripts.forEach((s) => {
+            const src = s.getAttribute('src') || '';
+            const content = s.innerHTML || '';
+            if (src)
+                scriptSources.push(src.toLowerCase());
+            if (content)
+                scriptContents.push(content.toLowerCase());
+        });
+        const allScriptText = scriptSources.join(' ') + ' ' + scriptContents.join(' ');
+        if (allScriptText.includes('gtag') && allScriptText.includes('g-')) {
+            providers.push('Google Analytics 4 (GA4)');
+        }
+        if (allScriptText.includes('analytics.js') || allScriptText.includes('ga.js') ||
+            (allScriptText.includes('ua-') && !allScriptText.includes('g-'))) {
+            providers.push('Universal Analytics (UA)');
+        }
+        if (allScriptText.includes('googletagmanager.com/gtm') || allScriptText.includes('gtm-')) {
+            providers.push('Google Tag Manager');
+        }
+        if (allScriptText.includes('hotjar.com') || allScriptText.includes('hj(')) {
+            providers.push('Hotjar');
+        }
+        if (allScriptText.includes('clarity.ms') || allScriptText.includes('clarity(')) {
+            providers.push('Microsoft Clarity');
+        }
+        if (allScriptText.includes('fullstory.com') || allScriptText.includes('fs.identify')) {
+            providers.push('FullStory');
+        }
+        if (allScriptText.includes('luckyorange.com')) {
+            providers.push('Lucky Orange');
+        }
+        if (allScriptText.includes('crazyegg.com')) {
+            providers.push('Crazy Egg');
+        }
+        if (allScriptText.includes('mixpanel.com') || allScriptText.includes('mixpanel.init')) {
+            providers.push('Mixpanel');
+        }
+        if (allScriptText.includes('heap.io') || allScriptText.includes('heapanalytics')) {
+            providers.push('Heap');
+        }
+        if (allScriptText.includes('amplitude.com') || allScriptText.includes('amplitude.init')) {
+            providers.push('Amplitude');
+        }
+        if (allScriptText.includes('segment.com') || allScriptText.includes('analytics.load')) {
+            providers.push('Segment');
+        }
+        if (allScriptText.includes('plausible.io')) {
+            providers.push('Plausible');
+        }
+        if (allScriptText.includes('matomo') || allScriptText.includes('piwik')) {
+            providers.push('Matomo');
+        }
+        if (allScriptText.includes('posthog.com') || allScriptText.includes('posthog.init')) {
+            providers.push('PostHog');
+        }
+        if (allScriptText.includes('connect.facebook.net') || allScriptText.includes('fbq(')) {
+            providers.push('Facebook Pixel');
+        }
+        if (allScriptText.includes('snap.licdn.com') || allScriptText.includes('_linkedin_partner_id')) {
+            providers.push('LinkedIn Insight');
+        }
+        if (allScriptText.includes('static.ads-twitter.com') || allScriptText.includes('twq(')) {
+            providers.push('Twitter Pixel');
+        }
+        if (allScriptText.includes('pintrk(') || allScriptText.includes('pinterest.com/ct')) {
+            providers.push('Pinterest Tag');
+        }
+        return {
+            analyticsDetected: providers.length > 0,
+            analyticsProviders: providers,
+        };
+    }
+    analyzeFeeds() {
+        let hasRssFeed = false;
+        let rssFeedUrl;
+        let hasAtomFeed = false;
+        let atomFeedUrl;
+        const rssLink = this.root.querySelector('link[type="application/rss+xml"]');
+        if (rssLink) {
+            hasRssFeed = true;
+            rssFeedUrl = rssLink.getAttribute('href') || undefined;
+        }
+        const atomLink = this.root.querySelector('link[type="application/atom+xml"]');
+        if (atomLink) {
+            hasAtomFeed = true;
+            atomFeedUrl = atomLink.getAttribute('href') || undefined;
+        }
+        return { hasRssFeed, rssFeedUrl, hasAtomFeed, atomFeedUrl };
+    }
+    analyzeConversionElements(links, visibleText) {
+        const formCount = this.root.querySelectorAll('form').length;
+        const ctaPatterns = [
+            /^(get started|start|begin|try|sign up|register|subscribe|join|buy|purchase|order|add to cart|checkout|download|contact|request|schedule|book|reserve|learn more|read more|discover|explore|view|see|watch|listen|play|submit|send|apply|claim|grab|unlock|access)$/i,
+            /^(obter|começar|iniciar|experimentar|inscrever|registrar|assinar|entrar|comprar|pedir|adicionar|finalizar|baixar|contato|solicitar|agendar|reservar|saber mais|ler mais|descobrir|explorar|ver|assistir|ouvir|enviar|aplicar|reivindicar|acessar)$/i,
+        ];
+        let ctaButtonsCount = 0;
+        this.root.querySelectorAll('button').forEach((btn) => {
+            const text = btn.text.trim().toLowerCase();
+            if (ctaPatterns.some(p => p.test(text))) {
+                ctaButtonsCount++;
+            }
+        });
+        this.root.querySelectorAll('a[class*="btn"], a[class*="button"], a[role="button"]').forEach((link) => {
+            const text = link.text.trim().toLowerCase();
+            if (ctaPatterns.some(p => p.test(text))) {
+                ctaButtonsCount++;
+            }
+        });
+        const hasWhatsAppLink = links.some(l => l.href.includes('wa.me') ||
+            l.href.includes('whatsapp.com') ||
+            l.href.includes('api.whatsapp.com'));
+        const phoneRegex = /(?:\+?\d{1,3}[-.\s]?)?\(?\d{2,4}\)?[-.\s]?\d{3,5}[-.\s]?\d{3,5}/g;
+        const hasPhoneOnPage = phoneRegex.test(visibleText) ||
+            links.some(l => l.href.startsWith('tel:'));
+        return {
+            ctaButtonsCount,
+            formCount,
+            hasWhatsAppLink,
+            hasPhoneOnPage,
+        };
+    }
+    analyzeAdvancedImages() {
+        let imagesWithSrcset = 0;
+        let largeBase64ImagesCount = 0;
+        const imgs = this.root.querySelectorAll('img');
+        imgs.forEach((img) => {
+            if (img.getAttribute('srcset') || (img.parentNode && img.parentNode.tagName === 'PICTURE')) {
+                imagesWithSrcset++;
+            }
+            const src = img.getAttribute('src') || '';
+            if (src.startsWith('data:image') && src.length > 5 * 1024) {
+                largeBase64ImagesCount++;
+            }
+        });
+        return { imagesWithSrcset, largeBase64ImagesCount };
+    }
+    calculateTextHtmlRatio(bodyTextLength) {
+        const htmlSize = this.root.innerHTML?.length;
+        if (htmlSize && htmlSize > 0) {
+            return (bodyTextLength / htmlSize) * 100;
+        }
+        return undefined;
+    }
+    convertToCheckResults(results) {
+        return results.map((r) => ({
+            name: r.name,
+            category: r.category,
+            status: r.status,
+            message: r.message,
+            value: r.value,
+            recommendation: r.recommendation,
+            evidence: r.evidence,
+        }));
+    }
+    buildSummary(ruleResults, checks, data) {
+        const passed = checks.filter((c) => c.status === 'pass').length;
+        const warnings = checks.filter((c) => c.status === 'warn').length;
+        const errors = checks.filter((c) => c.status === 'fail').length;
+        const infos = checks.filter((c) => c.status === 'info').length;
+        const totalChecks = checks.length;
+        const scoringChecks = totalChecks - infos;
+        const passRate = scoringChecks > 0 ? Math.round((passed / scoringChecks) * 100) : 100;
+        const issuesByCategory = {};
+        for (const result of ruleResults) {
+            const cat = result.category;
+            if (!issuesByCategory[cat]) {
+                issuesByCategory[cat] = { passed: 0, warnings: 0, errors: 0 };
+            }
+            if (result.status === 'pass')
+                issuesByCategory[cat].passed++;
+            else if (result.status === 'warn')
+                issuesByCategory[cat].warnings++;
+            else if (result.status === 'fail')
+                issuesByCategory[cat].errors++;
+        }
+        const topIssues = ruleResults
+            .filter((r) => r.status === 'fail' || r.status === 'warn')
+            .sort((a, b) => {
+            if (a.status === 'fail' && b.status !== 'fail')
+                return -1;
+            if (a.status !== 'fail' && b.status === 'fail')
+                return 1;
+            return 0;
+        })
+            .slice(0, 5)
+            .map((r) => ({
+            name: r.name,
+            message: r.message,
+            category: r.category,
+            severity: (r.status === 'fail' ? 'error' : 'warning'),
+        }));
+        const quickWins = [];
+        if (!data.meta.title)
+            quickWins.push('Add a page title');
+        if (!data.meta.description)
+            quickWins.push('Add a meta description');
+        if (!data.og.title && !data.og.description)
+            quickWins.push('Add OpenGraph meta tags for social sharing');
+        if (!data.twitter.card)
+            quickWins.push('Add Twitter Card meta tags');
+        if (!data.technical.hasCanonical)
+            quickWins.push('Add a canonical URL');
+        if (!data.technical.hasLang)
+            quickWins.push('Add lang attribute to <html>');
+        if (data.imageAnalysis.withoutAlt > 0)
+            quickWins.push(`Add alt text to ${data.imageAnalysis.withoutAlt} image(s)`);
+        if (data.linkAnalysis.withoutText > 0)
+            quickWins.push(`Add text to ${data.linkAnalysis.withoutText} empty link(s)`);
+        const limitedQuickWins = quickWins.slice(0, 5);
+        const htmlSize = this.root.innerHTML?.length;
+        const domElements = this.root.querySelectorAll('*').length;
+        const vitals = {
+            htmlSize,
+            domElements,
+            ttfb: this.options.responseHeaders ? undefined : undefined,
+            totalTime: undefined,
+            wordCount: data.content.wordCount,
+            readingTime: data.content.readingTimeMinutes,
+            imageCount: data.imageAnalysis.total,
+            linkCount: data.linkAnalysis.total,
+        };
+        const completeness = {
+            meta: this.calculateMetaCompleteness(data.meta),
+            social: this.calculateSocialCompleteness(data.og, data.twitter),
+            technical: this.calculateTechnicalCompleteness(data.technical),
+            content: this.calculateContentCompleteness(data.content),
+            images: this.calculateImageCompleteness(data.imageAnalysis),
+            links: this.calculateLinkCompleteness(data.linkAnalysis),
+        };
+        return {
+            totalChecks,
+            passed,
+            warnings,
+            errors,
+            infos,
+            passRate,
+            issuesByCategory,
+            topIssues,
+            quickWins: limitedQuickWins,
+            vitals,
+            completeness,
+        };
+    }
+    calculateMetaCompleteness(meta) {
+        let score = 0;
+        const total = 5;
+        if (meta.title)
+            score++;
+        if (meta.description)
+            score++;
+        if (meta.canonical)
+            score++;
+        if (meta.viewport)
+            score++;
+        if (meta.charset)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateSocialCompleteness(og, twitter) {
+        let score = 0;
+        const total = 8;
+        if (og.title)
+            score++;
+        if (og.description)
+            score++;
+        if (og.image)
+            score++;
+        if (og.url)
+            score++;
+        if (twitter.card)
+            score++;
+        if (twitter.title)
+            score++;
+        if (twitter.description)
+            score++;
+        if (twitter.image)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateTechnicalCompleteness(technical) {
+        let score = 0;
+        const total = 5;
+        if (technical.hasCanonical)
+            score++;
+        if (technical.hasViewport)
+            score++;
+        if (technical.hasCharset)
+            score++;
+        if (technical.hasLang)
+            score++;
+        if (technical.hasRobotsMeta)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateContentCompleteness(content) {
+        let score = 0;
+        const total = 5;
+        if (content.wordCount >= 300)
+            score++;
+        if (content.paragraphCount >= 3)
+            score++;
+        if (content.listCount > 0)
+            score++;
+        if (content.readingTimeMinutes >= 1)
+            score++;
+        if (content.strongTagCount > 0 || content.emTagCount > 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateImageCompleteness(images) {
+        if (images.total === 0)
+            return 100;
+        let score = 0;
+        const total = 4;
+        if (images.withoutAlt === 0)
+            score++;
+        if (images.lazy > 0)
+            score++;
+        if (images.missingDimensions === 0)
+            score++;
+        if (images.modernFormats > 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    calculateLinkCompleteness(links) {
+        if (links.total === 0)
+            return 100;
+        let score = 0;
+        const total = 4;
+        if (links.internal > 0)
+            score++;
+        if (links.external > 0)
+            score++;
+        if (links.withoutText === 0)
+            score++;
+        if (links.broken === 0)
+            score++;
+        return Math.round((score / total) * 100);
+    }
+    analyzeHeadings() {
+        const issues = [];
+        const structure = [];
+        const sectionWordCounts = [];
+        const counts = {
+            1: 0,
+            2: 0,
+            3: 0,
+            4: 0,
+            5: 0,
+            6: 0,
+        };
+        let currentSectionWordCount = 0;
+        let inSection = false;
+        const body = this.getMainBody();
+        const allElements = body ? body.querySelectorAll('*') : [];
+        allElements.forEach((el) => {
+            const tagName = el.tagName.toLowerCase();
+            if (tagName.match(/^h[1-6]$/)) {
+                const level = parseInt(tagName.substring(1), 10);
+                const text = el.text.trim();
+                counts[level] = (counts[level] || 0) + 1;
+                structure.push({ level, text: text.slice(0, 80), count: 1 });
+                if (level === 2) {
+                    if (inSection) {
+                        sectionWordCounts.push(currentSectionWordCount);
+                    }
+                    currentSectionWordCount = 0;
+                    inSection = true;
+                }
+            }
+            else if (inSection &&
+                ['p', 'ul', 'ol', 'div', 'article', 'section'].includes(tagName)) {
+                let text = '';
+                el.childNodes.forEach(n => {
+                    if (n.nodeType === 3)
+                        text += n.text;
+                });
+                text = text.trim();
+                if (text.length > 0) {
+                    currentSectionWordCount += text.split(/\s+/).length;
+                }
+            }
+        });
+        if (inSection) {
+            sectionWordCounts.push(currentSectionWordCount);
+        }
+        let hasProperHierarchy = true;
+        let prevLevel = 0;
+        for (const heading of structure) {
+            if (heading.level > prevLevel + 1 && prevLevel !== 0) {
+                hasProperHierarchy = false;
+                issues.push(`Skipped heading level: H${prevLevel} to H${heading.level}`);
+            }
+            prevLevel = heading.level;
+        }
+        if (counts[1] === 0) {
+            issues.push('No H1 tag found');
+        }
+        else if (counts[1] > 1) {
+            issues.push('Multiple H1 tags');
+        }
+        return {
+            structure,
+            h1Count: counts[1],
+            hasProperHierarchy,
+            issues,
+            sectionWordCounts,
+        };
+    }
+    analyzeContent(headings) {
+        const body = this.getMainBody();
+        const bodyText = body ? body.text.replace(/\s+/g, ' ').trim() : '';
+        const words = bodyText.split(/\s+/).filter((w) => w.length > 0);
+        const sentences = bodyText
+            .split(/[.!?]+/)
+            .filter((s) => s.trim().length > 0);
+        const paragraphs = this.root.querySelectorAll('p');
+        let totalParagraphLength = 0;
+        const paragraphWordCounts = [];
+        paragraphs.forEach((el) => {
+            const text = el.text.trim();
+            totalParagraphLength += text.length;
+            const pWords = text.split(/\s+/).filter((w) => w.length > 0).length;
+            if (pWords > 0)
+                paragraphWordCounts.push(pWords);
+        });
+        const wordCount = words.length;
+        const readingTimeMinutes = Math.ceil(wordCount / 200);
+        const avgWordsPerSentence = sentences.length > 0 ? Math.round(wordCount / sentences.length) : 0;
+        let faqCount = 0;
+        headings.structure.forEach((h) => {
+            if (h.level === 3 &&
+                /^(what|how|why|when|where|who|can|do|is|are)\b/i.test(h.text)) {
+                faqCount++;
+            }
+        });
+        const imageCount = this.root.querySelectorAll('img').length;
+        const imagePerWordRatio = wordCount > 0 ? imageCount / wordCount : 0;
+        const fleschReadingEase = undefined;
+        const hasQuestionHeadings = headings.structure.some((h) => (h.level === 2 || h.level === 3) &&
+            /^(what|how|why|when|where|who|can|do|is|are)\b/i.test(h.text));
+        return {
+            wordCount,
+            characterCount: bodyText.length,
+            sentenceCount: sentences.length,
+            paragraphCount: paragraphs.length,
+            readingTimeMinutes,
+            avgWordsPerSentence,
+            avgParagraphLength: paragraphs.length > 0
+                ? Math.round(totalParagraphLength / paragraphs.length)
+                : 0,
+            listCount: this.root.querySelectorAll('ul, ol').length,
+            strongTagCount: this.root.querySelectorAll('strong').length,
+            emTagCount: this.root.querySelectorAll('em').length,
+            paragraphWordCounts,
+            avgSentenceLength: avgWordsPerSentence,
+            faqCount,
+            imagePerWordRatio,
+            fleschReadingEase,
+            hasQuestionHeadings,
+        };
+    }
+    buildLinkAnalysis(links) {
+        const internalHttpLinkUrls = links
+            .filter((l) => l.type === 'internal' && l.href.startsWith('http://'))
+            .map((l) => l.href);
+        return {
+            total: links.length,
+            internal: links.filter((l) => l.type === 'internal').length,
+            external: links.filter((l) => l.type === 'external').length,
+            nofollow: links.filter((l) => l.rel?.includes('nofollow')).length,
+            sponsoredLinks: links.filter((l) => l.rel?.includes('sponsored')).length,
+            ugcLinks: links.filter((l) => l.rel?.includes('ugc')).length,
+            broken: 0,
+            withoutText: links.filter((l) => !l.text?.trim()).length,
+            internalHttpLinks: internalHttpLinkUrls.length,
+            internalHttpLinkUrls,
+        };
+    }
+    buildImageAnalysis(images) {
+        return {
+            total: images.length,
+            withAlt: images.filter((i) => i.alt && i.alt.trim().length > 0).length,
+            withoutAlt: images.filter((i) => !i.alt || i.alt.trim().length === 0).length,
+            lazy: images.filter((i) => i.loading === 'lazy').length,
+            missingDimensions: images.filter((i) => !i.width || !i.height).length,
+            modernFormats: images.filter((i) => /\.(webp|avif)$/i.test(i.src))
+                .length,
+            altTextLengths: images.filter((i) => i.alt).map((i) => i.alt.length),
+            imageAltTexts: images.filter((i) => i.alt).map((i) => i.alt.toLowerCase()),
+            imageFilenames: images
+                .map((i) => {
+                try {
+                    const url = new URL(i.src);
+                    return url.pathname.split('/').pop() || '';
+                }
+                catch {
+                    return '';
+                }
+            })
+                .filter(Boolean),
+            imagesWithAsyncDecoding: images.filter((i) => i.decoding === 'async')
+                .length,
+        };
+    }
+    buildSocialAnalysis(og, twitter) {
+        const ogIssues = [];
+        const twitterIssues = [];
+        const hasOg = !!(og.title || og.description || og.image);
+        if (!hasOg) {
+            ogIssues.push('No OpenGraph meta tags found');
+        }
+        else {
+            if (!og.title)
+                ogIssues.push('Missing og:title');
+            if (!og.description)
+                ogIssues.push('Missing og:description');
+            if (!og.image)
+                ogIssues.push('Missing og:image');
+            if (!og.url)
+                ogIssues.push('Missing og:url');
+        }
+        const hasTwitter = !!(twitter.card || twitter.title || twitter.description);
+        if (!hasTwitter) {
+            twitterIssues.push('No Twitter Card meta tags found');
+        }
+        else {
+            if (!twitter.card)
+                twitterIssues.push('Missing twitter:card');
+            if (!twitter.title)
+                twitterIssues.push('Missing twitter:title');
+            if (!twitter.description)
+                twitterIssues.push('Missing twitter:description');
+        }
+        return {
+            openGraph: {
+                present: hasOg,
+                hasTitle: !!og.title,
+                hasDescription: !!og.description,
+                hasImage: !!og.image,
+                hasUrl: !!og.url,
+                issues: ogIssues,
+            },
+            twitterCard: {
+                present: hasTwitter,
+                hasCard: !!twitter.card,
+                hasTitle: !!twitter.title,
+                hasDescription: !!twitter.description,
+                hasImage: !!twitter.image,
+                issues: twitterIssues,
+            },
+        };
+    }
+    buildTechnicalAnalysis(meta) {
+        const html = this.root.querySelector('html');
+        const htmlLang = html ? html.getAttribute('lang') : undefined;
+        return {
+            hasCanonical: !!meta.canonical,
+            canonicalUrl: meta.canonical,
+            hasRobotsMeta: !!meta.robots,
+            robotsContent: meta.robots,
+            hasViewport: !!meta.viewport,
+            hasCharset: !!meta.charset,
+            hasLang: !!htmlLang,
+            langValue: htmlLang,
+        };
+    }
+    analyzeResources() {
+        const scripts = this.root.querySelectorAll('script[src]');
+        const styles = this.root.querySelectorAll('link[rel="stylesheet"]');
+        const unminified = [];
+        scripts.forEach((s) => {
+            const src = s.getAttribute('src');
+            if (src && !src.includes('.min.') && !src.includes('cdn'))
+                unminified.push(src);
+        });
+        styles.forEach((s) => {
+            const href = s.getAttribute('href');
+            if (href && !href.includes('.min.') && !href.includes('cdn'))
+                unminified.push(href);
+        });
+        return {
+            jsFilesCount: scripts.length,
+            cssFilesCount: styles.length,
+            unminifiedResources: unminified.length,
+            unminifiedResourceUrls: unminified
+        };
+    }
+    calculateScore(checks) {
+        const weights = {
+            pass: 100,
+            warn: 50,
+            fail: 0,
+            info: 100,
+        };
+        const scoringChecks = checks.filter((c) => c.status !== 'info');
+        if (scoringChecks.length === 0)
+            return { score: 100, grade: 'A' };
+        const totalWeight = scoringChecks.reduce((sum, check) => sum + weights[check.status], 0);
+        const score = Math.round(totalWeight / scoringChecks.length);
+        let grade;
+        if (score >= 90)
+            grade = 'A';
+        else if (score >= 80)
+            grade = 'B';
+        else if (score >= 70)
+            grade = 'C';
+        else if (score >= 60)
+            grade = 'D';
+        else
+            grade = 'F';
+        return { score, grade };
+    }
+    getRules() {
+        return this.rulesEngine.getRules();
+    }
+    getRulesByCategory(category) {
+        return this.rulesEngine.getRulesByCategory(category);
+    }
+    getCategories() {
+        return this.rulesEngine.getCategories();
+    }
+}
+export async function analyzeSeo(html, options = {}) {
+    const analyzer = await SeoAnalyzer.fromHtml(html, options);
+    return analyzer.analyze();
+}
+export { SEO_THRESHOLDS, createRulesEngine, SeoRulesEngine, } from './rules/index.js';