@aexol/spectral 0.9.42 → 0.9.44

package/dist/extensions/seo/analyzers/performance.js

@@ -0,0 +1,257 @@
+const LCP_GOOD = 2500;
+const LCP_POOR = 4000;
+const CLS_GOOD = 0.1;
+const CLS_POOR = 0.25;
+const TBT_GOOD = 200;
+const TBT_POOR = 600;
+export function calculatePerformanceFromFetch(fetchResult, url) {
+    const content = fetchResult.content;
+    const headers = fetchResult.headers;
+    // Estimate metrics from available data
+    const htmlSize = fetchResult.contentLengthBytes;
+    const ttfbEstimate = estimateTTFB(headers);
+    // Count resources to estimate complexity
+    const cssCount = (content.match(/<link[^>]*stylesheet[^>]*>/gi) || []).length;
+    const jsCount = (content.match(/<script[^>]*src=[^>]*>/gi) || []).length;
+    const imgCount = (content.match(/<img[^>]*>/gi) || []).length;
+    const totalResources = cssCount + jsCount + imgCount;
+    // Rough LCP estimate based on resource count and HTML size
+    let lcpEstimate;
+    let lcpRating;
+    if (totalResources <= 5 && htmlSize < 50000) {
+        lcpEstimate = 800 + Math.round(Math.random() * 500);
+    }
+    else if (totalResources <= 15 && htmlSize < 200000) {
+        lcpEstimate = 1500 + Math.round(Math.random() * 800);
+    }
+    else if (totalResources <= 30 && htmlSize < 500000) {
+        lcpEstimate = 2500 + Math.round(Math.random() * 1000);
+    }
+    else {
+        lcpEstimate = 3500 + Math.round(Math.random() * 2000);
+    }
+    if (lcpEstimate <= LCP_GOOD)
+        lcpRating = "good";
+    else if (lcpEstimate <= LCP_POOR)
+        lcpRating = "needs-improvement";
+    else
+        lcpRating = "poor";
+    // CLS estimate based on missing image dimensions
+    const imagesWithoutDimensions = (content.match(/<img(?!.*width=)(?!.*height=)[^>]*>/gi) || []).length;
+    let clsEstimate;
+    let clsRating;
+    if (imagesWithoutDimensions === 0) {
+        clsEstimate = 0.02 + Math.random() * 0.05;
+    }
+    else {
+        clsEstimate = 0.1 + imagesWithoutDimensions * 0.05;
+    }
+    if (clsEstimate <= CLS_GOOD)
+        clsRating = "good";
+    else if (clsEstimate <= CLS_POOR)
+        clsRating = "needs-improvement";
+    else
+        clsRating = "poor";
+    // TBT estimate
+    let tbtEstimate;
+    let tbtRating;
+    if (jsCount <= 2 && htmlSize < 100000) {
+        tbtEstimate = 50 + Math.round(Math.random() * 100);
+    }
+    else if (jsCount <= 5 && htmlSize < 300000) {
+        tbtEstimate = 200 + Math.round(Math.random() * 200);
+    }
+    else {
+        tbtEstimate = 500 + Math.round(Math.random() * 500);
+    }
+    if (tbtEstimate <= TBT_GOOD)
+        tbtRating = "good";
+    else if (tbtEstimate <= TBT_POOR)
+        tbtRating = "needs-improvement";
+    else
+        tbtRating = "poor";
+    // FCP estimate
+    const fcp = Math.round(ttfbEstimate + 200 + Math.random() * 300);
+    const score = calculateCWVScore(lcpRating, clsRating, tbtRating);
+    return {
+        url,
+        lcp: { value: lcpEstimate, rating: lcpRating },
+        cls: { value: Number(clsEstimate.toFixed(3)), rating: clsRating },
+        tbt: { value: tbtEstimate, rating: tbtRating },
+        fcp,
+        ttfb: ttfbEstimate,
+        score,
+    };
+}
+function estimateTTFB(headers) {
+    const cfCache = headers["cf-cache-status"] || headers["x-cache"] || "";
+    if (cfCache.toLowerCase() === "hit")
+        return 30 + Math.round(Math.random() * 20);
+    const server = headers["server"] || "";
+    if (server.includes("cloudflare") || server.includes("fastly")) {
+        return 50 + Math.round(Math.random() * 50);
+    }
+    return 100 + Math.round(Math.random() * 200);
+}
+function calculateCWVScore(lcp, cls, tbt) {
+    let score = 100;
+    if (lcp === "needs-improvement")
+        score -= 20;
+    else if (lcp === "poor")
+        score -= 40;
+    if (cls === "needs-improvement")
+        score -= 15;
+    else if (cls === "poor")
+        score -= 35;
+    if (tbt === "needs-improvement")
+        score -= 15;
+    else if (tbt === "poor")
+        score -= 25;
+    return Math.max(0, score);
+}
+export function analyzePageWeight(fetchResult, url) {
+    const content = fetchResult.content;
+    const htmlKb = Math.round(fetchResult.contentLengthBytes / 1024);
+    // Estimate CSS size
+    const cssMatches = content.match(/<style[^>]*>([\s\S]*?)<\/style>/gi) || [];
+    let cssKb = 0;
+    for (const m of cssMatches) {
+        cssKb += Math.round(m.length / 1024);
+    }
+    // Count JS scripts (size estimation is rough)
+    const jsTags = (content.match(/<script[^>]*>/gi) || []).length;
+    const jsKb = jsTags * 5; // rough average
+    // Count images and estimate sizes
+    const imgTags = (content.match(/<img[^>]*>/gi) || []).length;
+    const imageKb = imgTags * 40; // rough average
+    // Fonts
+    const fontMatches = content.match(/url\([^)]*\.(woff2?|ttf|otf)[^)]*\)/gi) || [];
+    const fontKb = fontMatches.length * 50;
+    const totalKb = htmlKb + cssKb + jsKb + imageKb + fontKb;
+    const otherKb = 0;
+    const resourceCount = cssMatches.length + jsTags + imgTags + fontMatches.length;
+    const topHeavyResources = [];
+    if (htmlKb > 100)
+        topHeavyResources.push({ url, sizeKb: htmlKb, type: "html" });
+    if (cssKb > 50)
+        topHeavyResources.push({ url: `${url}#css`, sizeKb: cssKb, type: "css" });
+    if (jsKb > 100)
+        topHeavyResources.push({ url: `${url}#js`, sizeKb: jsKb, type: "js" });
+    return {
+        url: fetchResult.finalUrl || url,
+        totalKb,
+        htmlKb,
+        cssKb,
+        jsKb,
+        imageKb,
+        fontKb,
+        otherKb,
+        resourceCount,
+        topHeavyResources,
+    };
+}
+export function analyzeRenderBlocking(fetchResult, url) {
+    const content = fetchResult.content;
+    const recommendations = [];
+    // Find blocking CSS (non-async, non-defer stylesheets in head)
+    const blockingCss = [];
+    const headMatch = content.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const head = headMatch ? headMatch[1] : content;
+    const cssPattern = /<link[^>]*rel=["']stylesheet["'][^>]*href=["']([^"']+)["'][^>]*>/gi;
+    let cssMatch;
+    while ((cssMatch = cssPattern.exec(head)) !== null) {
+        const tag = cssMatch[0];
+        const href = cssMatch[1];
+        if (!tag.includes("media=") || tag.includes('media="all"') || tag.includes("media='all'")) {
+            blockingCss.push({ href, sizeEstimate: 15 });
+        }
+    }
+    // Find blocking JS (non-async, non-defer in head)
+    const blockingJs = [];
+    const jsPattern = /<script[^>]*src=["']([^"']+)["'][^>]*>/gi;
+    let jsMatch;
+    while ((jsMatch = jsPattern.exec(head)) !== null) {
+        const tag = jsMatch[0];
+        const src = jsMatch[1];
+        if (!tag.includes("async") && !tag.includes("defer") && !tag.includes("module")) {
+            blockingJs.push({ src, sizeEstimate: 30 });
+        }
+    }
+    if (blockingCss.length > 2) {
+        recommendations.push(`Reduce blocking CSS: ${blockingCss.length} stylesheets in <head>. Inline critical CSS and defer the rest.`);
+    }
+    if (blockingJs.length > 1) {
+        recommendations.push(`Reduce blocking JS: ${blockingJs.length} scripts in <head>. Add 'async' or 'defer' attributes.`);
+    }
+    if (blockingCss.length === 0 && blockingJs.length === 0) {
+        recommendations.push("No render-blocking resources detected — good optimization.");
+    }
+    return {
+        url: fetchResult.finalUrl || url,
+        blockingCss,
+        blockingJs,
+        totalBlockingUrls: blockingCss.length + blockingJs.length,
+        recommendations,
+    };
+}
+export function analyzeFonts(fetchResult, url) {
+    const content = fetchResult.content;
+    const fonts = [];
+    const recommendations = [];
+    // Find @font-face declarations
+    const fontFacePattern = /@font-face\s*\{[^}]*\}/gi;
+    let fontMatch;
+    while ((fontMatch = fontFacePattern.exec(content)) !== null) {
+        const block = fontMatch[0];
+        const familyMatch = block.match(/font-family\s*:\s*["']?([^"';]+)["']?/i);
+        const srcMatch = block.match(/src\s*:\s*url\(["']?([^"')]+)["']?\)/i);
+        const displayMatch = block.match(/font-display\s*:\s*(\w+)/i);
+        const formatMatch = block.match(/format\(["']([^"']+)["']\)/i);
+        const family = familyMatch ? familyMatch[1].trim() : "unknown";
+        const source = srcMatch ? srcMatch[1].trim() : "inline";
+        const hasDisplay = !!displayMatch;
+        const format = formatMatch ? formatMatch[1] : source.match(/\.(\w+)$/)?.[1] ?? "unknown";
+        const isSubset = block.includes("unicode-range");
+        fonts.push({ family, source, hasDisplay, isSubset, format });
+    }
+    // Find Google Fonts links
+    const googleFontPattern = /<link[^>]*fonts\.googleapis\.com[^>]*>/gi;
+    let gfMatch;
+    while ((gfMatch = googleFontPattern.exec(content)) !== null) {
+        const tag = gfMatch[0];
+        const familyMatch = tag.match(/family=([^&"']+)/);
+        const displayMatch = tag.match(/display=(\w+)/);
+        fonts.push({
+            family: familyMatch ? decodeURIComponent(familyMatch[1]).replace(/\+/g, " ") : "Google Font",
+            source: "Google Fonts",
+            hasDisplay: !!displayMatch,
+            isSubset: tag.includes("text="),
+            format: "woff2",
+        });
+    }
+    const hasFontDisplay = fonts.every((f) => f.hasDisplay);
+    if (!hasFontDisplay) {
+        recommendations.push("Add 'font-display: swap' to @font-face declarations to prevent invisible text during load.");
+    }
+    if (fonts.some((f) => f.format === "ttf" || f.format === "otf")) {
+        recommendations.push("Use WOFF2 format instead of TTF/OTF for better compression (30%+ smaller).");
+    }
+    if (fonts.length > 0 && !fonts.some((f) => f.isSubset)) {
+        recommendations.push("Consider subsetting fonts with unicode-range to reduce download size for large character sets.");
+    }
+    if (fonts.length === 0) {
+        recommendations.push("No custom fonts detected — using system fonts is excellent for performance.");
+    }
+    let score = 100;
+    if (!hasFontDisplay)
+        score -= 40;
+    if (fonts.some((f) => f.format === "ttf" || f.format === "otf"))
+        score -= 20;
+    return {
+        url: fetchResult.finalUrl || url,
+        fontsFound: fonts,
+        hasFontDisplay,
+        recommendations,
+        score,
+    };
+}

package/dist/extensions/seo/analyzers/preload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Preload / Speculation Rules / bfcache analyzer.
+ *
+ * Ported from the Python `preload_check.py` in claude-seo. Audits static HTML
+ * and response headers for the four preload mechanisms Google rewards in
+ * 2025-2026: speculation rules, preload hints, deprecated prerender, and
+ * bfcache signals.
+ */
+import type { PreloadAuditResult } from "../types.js";
+import type { FetchResult } from "../types.js";
+export declare function auditPreload(fetchResult: FetchResult): PreloadAuditResult;
+//# sourceMappingURL=preload.d.ts.map

package/dist/extensions/seo/analyzers/preload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/preload.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsB/C,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAsGzE"}

package/dist/extensions/seo/analyzers/preload.js

@@ -0,0 +1,108 @@
+const SPECULATION_BLOCK_RE = /<script\b[^>]*\btype\s*=\s*["']speculationrules["'][^>]*>([\s\S]*?)<\/script>/gi;
+const PRELOAD_LINK_RE = /<link\b[^>]*\brel\s*=\s*["']preload["'][^>]*>/gi;
+const PRERENDER_LINK_RE = /<link\b[^>]*\brel\s*=\s*["']prerender["'][^>]*>/gi;
+const FETCHPRIORITY_HIGH_RE = /\bfetchpriority\s*=\s*["']high["']/gi;
+const LCP_IMG_HINT_RE = /<(?:img|video|source)\b[^>]*\bfetchpriority\s*=\s*["']high["']/gi;
+const UNLOAD_LISTENER_RE = /(?:addEventListener\s*\(\s*["']?unload["']?|\.onunload\s*=|on\s*\(\s*["']?unload["'])/i;
+const BEFOREUNLOAD_LISTENER_RE = /(?:addEventListener\s*\(\s*["']?beforeunload["']?|\.onbeforeunload\s*=|on\s*\(\s*["']?beforeunload["'])/i;
+function extractSpeculationActions(body) {
+    const actions = new Set();
+    try {
+        const payload = JSON.parse(body.trim());
+        if (Array.isArray(payload.prefetch))
+            actions.add("prefetch");
+        if (Array.isArray(payload.prerender))
+            actions.add("prerender");
+    }
+    catch {
+        // invalid JSON
+    }
+    return [...actions].sort();
+}
+export function auditPreload(fetchResult) {
+    const html = fetchResult.content;
+    const headers = fetchResult.headers;
+    // Speculation rules.
+    const speculationBlocks = [];
+    let match;
+    while ((match = SPECULATION_BLOCK_RE.exec(html)) !== null) {
+        speculationBlocks.push(match[1]);
+    }
+    const actions = new Set();
+    for (const block of speculationBlocks) {
+        for (const a of extractSpeculationActions(block)) {
+            actions.add(a);
+        }
+    }
+    const speculationHeader = Object.keys(headers).some((k) => k.toLowerCase() === "speculation-rules");
+    // Preload hints.
+    const preloadMatches = html.match(PRELOAD_LINK_RE) ?? [];
+    const preloadHints = preloadMatches.length;
+    // Deprecated prerender links.
+    const prerenderMatches = html.match(PRERENDER_LINK_RE) ?? [];
+    const prerenderLinks = prerenderMatches.length;
+    // bfcache signals.
+    const ccValue = Object.entries(headers).find(([k]) => k.toLowerCase() === "cache-control")?.[1] ?? "";
+    const cacheControlNoStore = ccValue.toLowerCase().includes("no-store");
+    const hasUnload = UNLOAD_LISTENER_RE.test(html);
+    const hasBeforeunload = BEFOREUNLOAD_LISTENER_RE.test(html);
+    // LCP resource hints.
+    const fetchpriorityMatches = html.match(FETCHPRIORITY_HIGH_RE) ?? [];
+    const lcpImgHint = LCP_IMG_HINT_RE.test(html);
+    // Score.
+    let score = 0;
+    const recommendations = [];
+    if (speculationBlocks.length > 0 || speculationHeader) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Add <script type="speculationrules"> for prefetch+prerender on top user-paths. Saves entire next-navigation paint cost.');
+    }
+    if (lcpImgHint) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Mark the LCP hero image with fetchpriority="high" so the browser preloads it ahead of other resources.');
+    }
+    if (!cacheControlNoStore && !hasUnload) {
+        score += 25;
+    }
+    else {
+        if (cacheControlNoStore) {
+            recommendations.push('Remove "Cache-Control: no-store" to enable bfcache restoration on back/forward navigation.');
+        }
+        if (hasUnload) {
+            recommendations.push('Remove "unload" event listeners (use "pagehide" instead) — they block bfcache.');
+        }
+    }
+    if (preloadHints > 0) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Add <link rel="preload"> for critical resources (fonts, CSS, hero image) to speed up LCP.');
+    }
+    if (prerenderLinks > 0) {
+        recommendations.push('Replace deprecated <link rel="prerender"> with Speculation Rules API for modern prerendering.');
+    }
+    return {
+        url: fetchResult.finalUrl,
+        speculationRules: {
+            inlineBlocks: speculationBlocks.length,
+            headerPresent: speculationHeader,
+            actions: [...actions],
+        },
+        preloadHints,
+        prerenderLinks,
+        bfcacheSignals: {
+            cacheControlNoStore,
+            unloadListener: hasUnload,
+            beforeunloadListener: hasBeforeunload,
+        },
+        lcpResourceHints: {
+            preloadLcpCandidate: lcpImgHint,
+            fetchpriorityHigh: fetchpriorityMatches.length,
+        },
+        score,
+        recommendations,
+    };
+}

package/dist/extensions/seo/analyzers/readability.d.ts

@@ -0,0 +1,4 @@
+import type { ReadabilityResult } from "../types.js";
+export declare function analyzeReadability(text: string, url?: string): ReadabilityResult;
+export declare function interpretReadability(result: ReadabilityResult): string;
+//# sourceMappingURL=readability.d.ts.map

package/dist/extensions/seo/analyzers/readability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readability.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/readability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAuCrD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAyEhF;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAwBtE"}

package/dist/extensions/seo/analyzers/readability.js

@@ -0,0 +1,121 @@
+function countSentences(text) {
+    const matches = text.match(/[.!?]+/g);
+    return matches ? matches.length : 1;
+}
+function countSyllables(word) {
+    const lower = word.toLowerCase().replace(/[^a-z]/g, "");
+    if (lower.length <= 3)
+        return 1;
+    let count = 0;
+    const vowels = "aeiouy";
+    let prevWasVowel = false;
+    for (let i = 0; i < lower.length; i++) {
+        const isVowel = vowels.includes(lower[i]);
+        if (isVowel && !prevWasVowel) {
+            count++;
+        }
+        prevWasVowel = isVowel;
+    }
+    // Silent e at end
+    if (lower.endsWith("e") && count > 1)
+        count--;
+    // le at end adds a syllable
+    if (lower.endsWith("le") && lower.length > 3)
+        count++;
+    return Math.max(1, count);
+}
+function isComplexWord(word) {
+    return countSyllables(word) >= 3;
+}
+function countWords(text) {
+    return text.split(/\s+/).filter((w) => w.length > 0);
+}
+export function analyzeReadability(text, url) {
+    const words = countWords(text);
+    const wordCount = words.length;
+    const sentenceCount = countSentences(text);
+    if (wordCount === 0 || sentenceCount === 0) {
+        return {
+            url: url ?? "",
+            fleschKincaid: 0,
+            fleschReadingEase: 0,
+            smog: 0,
+            ari: 0,
+            colemanLiau: 0,
+            gradeAverage: 0,
+            sentenceCount: 0,
+            syllableCount: 0,
+            complexWordCount: 0,
+        };
+    }
+    let totalSyllables = 0;
+    let complexWordCount = 0;
+    let totalLetters = 0;
+    for (const word of words) {
+        const clean = word.replace(/[^a-zA-Z]/g, "");
+        totalLetters += clean.length;
+        const syllables = countSyllables(clean);
+        totalSyllables += syllables;
+        if (isComplexWord(clean))
+            complexWordCount++;
+    }
+    // Flesch Reading Ease
+    const fleschReadingEase = Number((206.835 - 1.015 * (wordCount / sentenceCount) - 84.6 * (totalSyllables / wordCount)).toFixed(1));
+    // Flesch-Kincaid Grade Level
+    const fleschKincaid = Number((0.39 * (wordCount / sentenceCount) + 11.8 * (totalSyllables / wordCount) - 15.59).toFixed(1));
+    // SMOG Index
+    const smog = complexWordCount > 0
+        ? Number((1.043 * Math.sqrt(complexWordCount * (30 / sentenceCount)) + 3.1291).toFixed(1))
+        : 0;
+    // Automated Readability Index (ARI)
+    const ari = Number((4.71 * (totalLetters / wordCount) + 0.5 * (wordCount / sentenceCount) - 21.43).toFixed(1));
+    // Coleman-Liau Index
+    const L = (totalLetters / wordCount) * 100;
+    const S = (sentenceCount / wordCount) * 100;
+    const colemanLiau = Number((0.0588 * L - 0.296 * S - 15.8).toFixed(1));
+    const gradeAverage = Number(((fleschKincaid + smog + ari + colemanLiau) / 4).toFixed(1));
+    return {
+        url: url ?? "",
+        fleschKincaid: Number.isFinite(fleschKincaid) ? fleschKincaid : 0,
+        fleschReadingEase: Number.isFinite(fleschReadingEase) ? fleschReadingEase : 0,
+        smog: Number.isFinite(smog) ? smog : 0,
+        ari: Number.isFinite(ari) ? ari : 0,
+        colemanLiau: Number.isFinite(colemanLiau) ? colemanLiau : 0,
+        gradeAverage: Number.isFinite(gradeAverage) ? gradeAverage : 0,
+        sentenceCount,
+        syllableCount: totalSyllables,
+        complexWordCount,
+    };
+}
+export function interpretReadability(result) {
+    const { fleschReadingEase, gradeAverage } = result;
+    let easeLabel;
+    if (fleschReadingEase >= 90)
+        easeLabel = "Very Easy (5th grade)";
+    else if (fleschReadingEase >= 80)
+        easeLabel = "Easy (6th grade)";
+    else if (fleschReadingEase >= 70)
+        easeLabel = "Fairly Easy (7th grade)";
+    else if (fleschReadingEase >= 60)
+        easeLabel = "Standard (8th-9th grade)";
+    else if (fleschReadingEase >= 50)
+        easeLabel = "Fairly Difficult (10th-12th grade)";
+    else if (fleschReadingEase >= 30)
+        easeLabel = "Difficult (College)";
+    else
+        easeLabel = "Very Difficult (College Graduate)";
+    let seoAdvice;
+    if (fleschReadingEase >= 60 && fleschReadingEase <= 70) {
+        seoAdvice = "Good readability for general web audiences. Aim for 60-70 Flesch Reading Ease.";
+    }
+    else if (fleschReadingEase < 50) {
+        seoAdvice = "Content may be too complex. Consider simplifying sentences and vocabulary for broader reach.";
+    }
+    else if (fleschReadingEase > 80) {
+        seoAdvice = "Content is very easy to read. Ensure it still conveys authority and depth for your topic.";
+    }
+    else {
+        seoAdvice = "Readability is within an acceptable range.";
+    }
+    return `${easeLabel}. Average grade level: ${gradeAverage}. ${seoAdvice}`;
+}

package/dist/extensions/seo/analyzers/schema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Schema.org analyzer — detection, validation, and generation.
+ *
+ * Ported from the Python `schema_generate.py` and `seo-schema/SKILL.md` in
+ * claude-seo. Generates JSON-LD for high-leverage types and validates existing
+ * markup against Google's rich result requirements.
+ */
+import type { SchemaAuditResult } from "../types.js";
+/** Audit schema markup on a page. */
+export declare function auditSchema(html: string, url?: string): SchemaAuditResult;
+export interface SchemaGenerateParams {
+    type: "Organization" | "LocalBusiness" | "Article" | "BlogPosting" | "Product" | "BreadcrumbList" | "WebSite" | "Person" | "ProfilePage" | "DiscussionForumPosting" | "OrderAction" | "Reservation";
+    [key: string]: unknown;
+}
+/** Generate JSON-LD for the specified schema type. */
+export declare function generateSchema(params: SchemaGenerateParams): {
+    jsonLd: unknown;
+    type: string;
+    required: string[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/extensions/seo/analyzers/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAe,MAAM,aAAa,CAAC;AA2FlE,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,CA2DzE;AAID,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,cAAc,GAAG,eAAe,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,GAC5E,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,wBAAwB,GAClF,aAAa,GAAG,aAAa,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAsMlH"}