recker 1.0.26 → 1.0.27-next.1cb21f8

package/dist/seo/analyzer.js

@@ -0,0 +1,715 @@
+import { extractMeta, extractOpenGraph, extractTwitterCard, extractJsonLd, extractLinks, extractImages, } from '../scrape/extractors.js';
+import { requireOptional } from '../utils/optional-require.js';
+import { createRulesEngine, SEO_THRESHOLDS, } from './rules/index.js';
+let cheerioModule = null;
+async function loadCheerio() {
+    if (cheerioModule)
+        return cheerioModule;
+    cheerioModule = await requireOptional('cheerio', 'recker/seo');
+    return cheerioModule;
+}
+export class SeoAnalyzer {
+    $;
+    options;
+    rulesEngine;
+    constructor($, options = {}) {
+        this.$ = $;
+        this.options = options;
+        this.rulesEngine = createRulesEngine(options.rules);
+    }
+    static async fromHtml(html, options = {}) {
+        const { load } = await loadCheerio();
+        return new SeoAnalyzer(load(html), options);
+    }
+    analyze() {
+        const url = this.options.baseUrl || '';
+        const meta = extractMeta(this.$);
+        const og = extractOpenGraph(this.$);
+        const twitter = extractTwitterCard(this.$);
+        const jsonLd = extractJsonLd(this.$);
+        const links = extractLinks(this.$, { baseUrl: this.options.baseUrl });
+        const images = extractImages(this.$, { baseUrl: this.options.baseUrl });
+        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 context = this.buildRuleContext({
+            meta,
+            og,
+            twitter,
+            jsonLd,
+            headings,
+            content,
+            linkAnalysis,
+            imageAnalysis,
+            links,
+        });
+        const ruleResults = this.rulesEngine.evaluate(context);
+        const checks = this.convertToCheckResults(ruleResults);
+        const { score, grade } = this.calculateScore(checks);
+        return {
+            url,
+            timestamp: new Date(),
+            grade,
+            score,
+            checks,
+            title: meta.title ? { text: meta.title, length: meta.title.length } : undefined,
+            metaDescription: meta.description ? { text: meta.description, length: meta.description.length } : undefined,
+            headings: headings,
+            content,
+            links: linkAnalysis,
+            images: imageAnalysis,
+            social,
+            technical,
+            jsonLd: {
+                count: jsonLd.length,
+                types: jsonLd.map((j) => j['@type']).filter(Boolean),
+            },
+        };
+    }
+    buildRuleContext(data) {
+        const { meta, og, twitter, jsonLd, headings, content, linkAnalysis, imageAnalysis, links } = data;
+        const htmlLang = this.$('html').attr('lang');
+        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) => !l.text || l.text.trim() === '');
+        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.$('h1');
+        const h1Text = h1Elements.first().text().trim();
+        const viewportContent = this.$('meta[name="viewport"]').attr('content');
+        const a11yMetrics = this.analyzeAccessibility();
+        const imagesWithEmptyAlt = this.$('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 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 {
+            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,
+            imageFilenames: imageAnalysis.imageFilenames,
+            imagesWithAsyncDecoding: imageAnalysis.imagesWithAsyncDecoding,
+            ...a11yMetrics,
+            allLinks: links,
+            totalLinks: linkAnalysis.total,
+            internalLinks: linkAnalysis.internal,
+            externalLinks: linkAnalysis.external,
+            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,
+            ...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),
+        };
+    }
+    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.$('script').length;
+        const noscriptContent = this.$('noscript').text().trim();
+        const hasNoscriptContent = noscriptContent.length > 50;
+        return { bodyTextLength, scriptCount, hasNoscriptContent };
+    }
+    checkMixedContent() {
+        let hasMixed = false;
+        this.$('img[src^="http://"]').each(() => {
+            hasMixed = true;
+        });
+        this.$('script[src^="http://"]').each(() => {
+            hasMixed = true;
+        });
+        this.$('link[href^="http://"]').each(() => {
+            hasMixed = true;
+        });
+        return hasMixed;
+    }
+    analyzeLinkSecurity() {
+        let withoutNoopener = 0;
+        let withoutNoreferrer = 0;
+        this.$('a[href^="http"][target="_blank"]').each((_, el) => {
+            const $el = this.$(el);
+            const href = $el.attr('href') || '';
+            const rel = ($el.attr('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.$(selector).first();
+            if (favicon.length > 0) {
+                return {
+                    hasFavicon: true,
+                    faviconUrl: favicon.attr('href'),
+                };
+            }
+        }
+        return { hasFavicon: false };
+    }
+    analyzePerformanceHints() {
+        const preconnectLinks = this.$('link[rel="preconnect"]');
+        const preconnectCount = preconnectLinks.length;
+        const dnsPrefetchLinks = this.$('link[rel="dns-prefetch"]');
+        const dnsPrefetchCount = dnsPrefetchLinks.length;
+        const preloadLinks = this.$('link[rel="preload"]');
+        const preloadCount = preloadLinks.length;
+        let renderBlockingResources = 0;
+        this.$('head script[src]:not([async]):not([defer])').each(() => {
+            renderBlockingResources++;
+        });
+        this.$('head link[rel="stylesheet"]').each((_, el) => {
+            const $el = this.$(el);
+            const media = $el.attr('media');
+            if (!media || media === 'all' || media === 'screen') {
+                renderBlockingResources++;
+            }
+        });
+        const inlineScriptsCount = this.$('script:not([src])').filter((_, el) => {
+            const content = this.$(el).html() || '';
+            return content.trim().length > 0;
+        }).length;
+        const inlineStylesCount = this.$('style').length;
+        return {
+            hasPreconnect: preconnectCount > 0,
+            preconnectCount,
+            hasDnsPrefetch: dnsPrefetchCount > 0,
+            dnsPrefetchCount,
+            hasPreload: preloadCount > 0,
+            preloadCount,
+            renderBlockingResources,
+            inlineScriptsCount,
+            inlineStylesCount,
+        };
+    }
+    analyzeCWVHints() {
+        const images = this.$('img');
+        let hasLargeImages = false;
+        let hasLazyLcp = false;
+        let hasPriorityHints = false;
+        images.slice(0, 3).each((index, el) => {
+            const $el = this.$(el);
+            const width = parseInt($el.attr('width') || '0', 10);
+            const height = parseInt($el.attr('height') || '0', 10);
+            const loading = $el.attr('loading');
+            const fetchPriority = $el.attr('fetchpriority');
+            if (width >= 400 || height >= 300) {
+                hasLargeImages = true;
+            }
+            if (index === 0 && loading === 'lazy') {
+                hasLazyLcp = true;
+            }
+            if (fetchPriority === 'high') {
+                hasPriorityHints = true;
+            }
+        });
+        this.$('[style*="background-image"]').slice(0, 3).each(() => {
+            hasLargeImages = true;
+        });
+        const imagesWithoutDimensions = this.$('img:not([width]):not([height])').length + this.$('img[width="auto"], img[height="auto"]').length;
+        return {
+            lcpHints: {
+                hasLargeImages,
+                hasLazyLcp,
+                hasPriorityHints,
+            },
+            clsHints: {
+                imagesWithoutDimensions,
+            },
+        };
+    }
+    analyzeAccessibility() {
+        let buttonsWithoutAriaLabel = 0;
+        this.$('button').each((_, el) => {
+            const $el = this.$(el);
+            const text = $el.text().trim();
+            const ariaLabel = $el.attr('aria-label');
+            const ariaLabelledBy = $el.attr('aria-labelledby');
+            const title = $el.attr('title');
+            if (!text && !ariaLabel && !ariaLabelledBy && !title) {
+                buttonsWithoutAriaLabel++;
+            }
+        });
+        let linksWithoutAriaLabel = 0;
+        this.$('a[href]').each((_, el) => {
+            const $el = this.$(el);
+            const text = $el.text().trim();
+            const ariaLabel = $el.attr('aria-label');
+            const ariaLabelledBy = $el.attr('aria-labelledby');
+            const title = $el.attr('title');
+            const hasOnlyImage = $el.find('img, svg').length > 0 && !text;
+            if (hasOnlyImage && !ariaLabel && !ariaLabelledBy && !title) {
+                linksWithoutAriaLabel++;
+            }
+        });
+        let inputsWithoutLabel = 0;
+        this.$('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="reset"]), select, textarea').each((_, el) => {
+            const $el = this.$(el);
+            const id = $el.attr('id');
+            const ariaLabel = $el.attr('aria-label');
+            const ariaLabelledBy = $el.attr('aria-labelledby');
+            const placeholder = $el.attr('placeholder');
+            const title = $el.attr('title');
+            const hasLabel = id ? this.$(`label[for="${id}"]`).length > 0 : false;
+            const wrappedInLabel = $el.closest('label').length > 0;
+            if (!hasLabel && !wrappedInLabel && !ariaLabel && !ariaLabelledBy && !title && !placeholder) {
+                inputsWithoutLabel++;
+            }
+        });
+        const iframesWithoutTitle = this.$('iframe:not([title])').length;
+        let tablesWithoutCaption = 0;
+        this.$('table').each((_, el) => {
+            const $el = this.$(el);
+            const hasCaption = $el.find('caption').length > 0;
+            const ariaLabel = $el.attr('aria-label');
+            const ariaLabelledBy = $el.attr('aria-labelledby');
+            const role = $el.attr('role');
+            if (role === 'presentation' || role === 'none')
+                return;
+            const hasHeaders = $el.find('th').length > 0;
+            if (hasHeaders && !hasCaption && !ariaLabel && !ariaLabelledBy) {
+                tablesWithoutCaption++;
+            }
+        });
+        let svgsWithoutTitle = 0;
+        this.$('svg').each((_, el) => {
+            const $el = this.$(el);
+            const hasTitle = $el.find('title').length > 0;
+            const ariaLabel = $el.attr('aria-label');
+            const ariaLabelledBy = $el.attr('aria-labelledby');
+            const ariaHidden = $el.attr('aria-hidden');
+            const role = $el.attr('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.$('header').length > 0,
+            hasNav: this.$('nav').length > 0,
+            hasMain: this.$('main').length > 0,
+            hasArticle: this.$('article').length > 0,
+            hasSection: this.$('section').length > 0,
+            hasFooter: this.$('footer').length > 0,
+        };
+    }
+    analyzeBreadcrumbs(jsonLdTypes) {
+        const hasBreadcrumbsHtml = this.$('nav[aria-label="breadcrumb"], .breadcrumb, .breadcrumbs').length > 0;
+        const hasBreadcrumbsSchema = jsonLdTypes.includes('BreadcrumbList');
+        return { hasBreadcrumbsHtml, hasBreadcrumbsSchema };
+    }
+    analyzeMultimedia() {
+        return {
+            videoCount: this.$('video').length,
+            audioCount: this.$('audio').length,
+        };
+    }
+    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')),
+        };
+    }
+    calculateTextHtmlRatio(bodyTextLength) {
+        const htmlSize = this.$('html').html()?.length;
+        if (htmlSize && htmlSize > 0) {
+            return (bodyTextLength / htmlSize) * 100;
+        }
+        return undefined;
+    }
+    convertToCheckResults(results) {
+        return results.map((r) => ({
+            name: r.name,
+            status: r.status,
+            message: r.message,
+            value: r.value,
+            recommendation: r.recommendation,
+            evidence: r.evidence,
+        }));
+    }
+    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;
+        this.$('body').find('*').each((_, el) => {
+            const tagName = el.tagName.toLowerCase();
+            if (tagName.match(/^h[1-6]$/)) {
+                const level = parseInt(tagName.substring(1), 10);
+                const text = this.$(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)) {
+                const text = this.$(el).clone().children().remove().end().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.$('body').clone();
+        $body.find('script, style, noscript, svg, header, footer, nav').remove();
+        const bodyText = $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.$('p');
+        let totalParagraphLength = 0;
+        const paragraphWordCounts = [];
+        paragraphs.each((_, el) => {
+            const text = this.$(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.$('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.$('ul, ol').length,
+            strongTagCount: this.$('strong').length,
+            emTagCount: this.$('em').length,
+            paragraphWordCounts,
+            avgSentenceLength: avgWordsPerSentence,
+            faqCount,
+            imagePerWordRatio,
+            fleschReadingEase,
+            hasQuestionHeadings,
+        };
+    }
+    buildLinkAnalysis(links) {
+        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,
+        };
+    }
+    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),
+            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 htmlLang = this.$('html').attr('lang');
+        return {
+            hasCanonical: !!meta.canonical,
+            canonicalUrl: meta.canonical,
+            hasRobotsMeta: !!meta.robots,
+            robotsContent: meta.robots,
+            hasViewport: !!meta.viewport,
+            hasCharset: !!meta.charset,
+            hasLang: !!htmlLang,
+            langValue: htmlLang,
+        };
+    }
+    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';