docusaurus-plugin-docusynx 0.1.0

package/dist/discover.js

@@ -0,0 +1,335 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import matter from 'gray-matter';
+export async function discoverDocuments(input) {
+    const documents = new Map();
+    let nextOrder = 0;
+    for (const value of objectValuesDeep(input.allContent)) {
+        const versions = arrayProperty(value, 'loadedVersions');
+        if (versions) {
+            for (const versionValue of versions) {
+                const version = asRecord(versionValue);
+                if (!version)
+                    continue;
+                const versionName = stringProperty(version, 'versionName') ??
+                    stringProperty(version, 'name') ??
+                    'current';
+                const prefix = versionName === 'current' ? '' : `${versionName}:`;
+                const docs = arrayProperty(version, 'docs') ?? [];
+                for (const docValue of docs) {
+                    const candidate = await candidateFromMetadata(docValue, input.siteDir, prefix, nextOrder++);
+                    if (candidate)
+                        documents.set(candidate.id, candidate);
+                }
+                applySidebars(version.sidebars, documents, prefix, () => nextOrder++);
+            }
+        }
+        const pages = arrayProperty(value, 'loadedPages');
+        if (pages) {
+            for (const pageValue of pages) {
+                const candidate = await candidateFromMetadata(pageValue, input.siteDir, 'page:', nextOrder++);
+                if (candidate) {
+                    // Pages can define local JSX components that have no stable import key.
+                    // Their rendered <main> content is the deterministic public contract.
+                    candidate.forceRendered = true;
+                    documents.set(candidate.id, candidate);
+                }
+            }
+        }
+    }
+    reconcileGeneratedIndexRoutes(documents, input.routePaths);
+    const routeSet = new Set([...documents.values()].map((document) => normalizeRoute(document.route)));
+    for (const route of [...input.routePaths].sort()) {
+        const normalizedRoute = normalizeRoute(route);
+        const exclusions = [
+            '/404.html',
+            '/404/',
+            ...(input.options.excludeRoutePatterns ?? []),
+        ];
+        if (matchesAny(normalizedRoute, exclusions) ||
+            matchesAny(route, exclusions))
+            continue;
+        if (routeSet.has(normalizedRoute))
+            continue;
+        if (!(await renderedRouteExists(input.outDir, normalizedRoute)))
+            continue;
+        const id = normalizedRoute === '/'
+            ? 'page:index'
+            : `route:${normalizedRoute.replace(/^\/|\/$/g, '')}`;
+        documents.set(id, {
+            id,
+            title: normalizedRoute === '/'
+                ? 'Home'
+                : titleFromRoute(normalizedRoute),
+            route: normalizedRoute,
+            sourcePath: `.docusaurus/routes${normalizedRoute}index.html`,
+            order: nextOrder++,
+            forceRendered: true,
+        });
+    }
+    for (const document of documents.values()) {
+        if (matchesAny(document.route, input.options.renderedRoutePatterns ?? []))
+            document.forceRendered = true;
+    }
+    return [...documents.values()].sort(compareCandidate);
+}
+async function candidateFromMetadata(value, siteDir, idPrefix, order) {
+    const outer = asRecord(value);
+    if (!outer)
+        return undefined;
+    const metadata = asRecord(outer.metadata) ?? outer;
+    const route = stringProperty(metadata, 'permalink') ??
+        stringProperty(metadata, 'route');
+    const rawSource = stringProperty(metadata, 'source') ??
+        stringProperty(metadata, 'sourcePath');
+    if (!route || !rawSource)
+        return undefined;
+    const absolute = resolveSourcePath(siteDir, rawSource);
+    let frontMatter = asRecord(metadata.frontMatter) ?? {};
+    try {
+        const parsed = matter(await readFile(absolute, 'utf8'));
+        frontMatter = { ...parsed.data, ...frontMatter };
+    }
+    catch {
+        // The rendered route remains available when a generated source is outside the site tree.
+    }
+    const routeId = normalizeRoute(route) === '/'
+        ? 'index'
+        : normalizeRoute(route).replace(/^\/|\/$/g, '');
+    const rawId = stringProperty(frontMatter, 'docusynx_id') ??
+        stringProperty(metadata, 'id') ??
+        routeId;
+    const sourceOverride = stringProperty(frontMatter, 'source_path') ??
+        stringProperty(frontMatter, 'docusynx_source_path');
+    return {
+        id: `${idPrefix}${rawId}`,
+        title: stringProperty(metadata, 'title') ??
+            stringProperty(frontMatter, 'title') ??
+            titleFromRoute(route),
+        route: normalizeRoute(route),
+        sourcePath: sourceOverride ?? normalizeSourcePath(siteDir, absolute, rawId),
+        sourcePathIsRepositoryRelative: sourceOverride !== undefined,
+        sourceAbsolutePath: absolute,
+        order,
+    };
+}
+function applySidebars(sidebarsValue, documents, prefix, nextOrder) {
+    const sidebars = asRecord(sidebarsValue);
+    if (!sidebars)
+        return;
+    for (const sidebarName of Object.keys(sidebars).sort()) {
+        const items = Array.isArray(sidebars[sidebarName])
+            ? sidebars[sidebarName]
+            : [];
+        walkSidebar(items, undefined, [sidebarName], documents, prefix, nextOrder);
+    }
+}
+function walkSidebar(items, parentId, ancestry, documents, prefix, nextOrder) {
+    items.forEach((itemValue, index) => {
+        const item = asRecord(itemValue);
+        if (!item)
+            return;
+        const type = stringProperty(item, 'type');
+        if (type === 'doc') {
+            const id = `${prefix}${stringProperty(item, 'id') ?? ''}`;
+            if (id === parentId)
+                return;
+            const document = documents.get(id);
+            if (document) {
+                document.parentId = parentId;
+                document.order = index;
+            }
+            return;
+        }
+        if (type !== 'category')
+            return;
+        const label = stringProperty(item, 'label') ?? 'Category';
+        const link = asRecord(item.link);
+        const explicitLinkedId = stringProperty(link ?? {}, 'type') === 'doc'
+            ? `${prefix}${stringProperty(link ?? {}, 'id') ?? ''}`
+            : undefined;
+        const linkedId = explicitLinkedId ??
+            indexDocumentId(item.items, documents, prefix);
+        const id = linkedId && documents.has(linkedId)
+            ? linkedId
+            : `${prefix}category:${slug([...ancestry, label].join('/'))}`;
+        if (!documents.has(id)) {
+            const route = stringProperty(link ?? {}, 'slug') ??
+                `/.docusynx/category/${slug([...ancestry, label].join('/'))}/`;
+            const generatedIndexRoute = stringProperty(link ?? {}, 'type') === 'generated-index'
+                ? normalizeRoute(route)
+                : undefined;
+            documents.set(id, {
+                id,
+                title: label,
+                route: normalizeRoute(route),
+                sourcePath: `.docusynx/categories/${slug([...ancestry, label].join('/'))}`,
+                parentId,
+                order: nextOrder(),
+                syntheticBlocks: [
+                    {
+                        type: 'heading',
+                        level: 1,
+                        inlines: [{ type: 'text', value: label }],
+                    },
+                ],
+                ...(generatedIndexRoute ? { generatedIndexRoute } : {}),
+            });
+        }
+        else {
+            const categoryDocument = documents.get(id);
+            if (categoryDocument) {
+                categoryDocument.parentId = parentId;
+                categoryDocument.order = index;
+            }
+        }
+        walkSidebar(Array.isArray(item.items) ? item.items : [], id, [...ancestry, label], documents, prefix, nextOrder);
+    });
+}
+function indexDocumentId(itemsValue, documents, prefix) {
+    if (!Array.isArray(itemsValue))
+        return undefined;
+    for (const itemValue of itemsValue) {
+        const item = asRecord(itemValue);
+        if (!item || stringProperty(item, 'type') !== 'doc')
+            continue;
+        const rawId = stringProperty(item, 'id') ?? '';
+        const basename = rawId.split('/').at(-1);
+        if (basename !== 'index' && basename !== 'overview')
+            continue;
+        const id = `${prefix}${rawId}`;
+        if (documents.has(id))
+            return id;
+    }
+    return undefined;
+}
+function reconcileGeneratedIndexRoutes(documents, routePaths) {
+    const normalizedRoutes = [...new Set(routePaths.map(normalizeRoute))].sort();
+    for (const document of documents.values()) {
+        if (!document.generatedIndexRoute)
+            continue;
+        const suffix = document.generatedIndexRoute;
+        const matches = normalizedRoutes.filter((route) => route === suffix || route.endsWith(suffix));
+        if (matches.length > 1) {
+            throw new Error(`generated-index category ${document.id} matches multiple rendered routes: ${matches.join(', ')}`);
+        }
+        const renderedRoute = matches[0];
+        if (!renderedRoute)
+            continue;
+        document.route = renderedRoute;
+        document.sourcePath = `.docusaurus/routes${renderedRoute}index.html`;
+        document.sourcePathIsRepositoryRelative = false;
+        document.syntheticBlocks = undefined;
+        document.forceRendered = true;
+    }
+}
+export async function readRenderedRoute(outDir, route) {
+    for (const candidate of renderedRouteCandidates(outDir, route)) {
+        try {
+            return await readFile(candidate, 'utf8');
+        }
+        catch {
+            // Try the next Docusaurus trailing-slash form.
+        }
+    }
+    throw new Error(`no rendered HTML found for route ${route}`);
+}
+async function renderedRouteExists(outDir, route) {
+    for (const candidate of renderedRouteCandidates(outDir, route)) {
+        try {
+            await access(candidate);
+            return true;
+        }
+        catch {
+            // Try the next form.
+        }
+    }
+    return false;
+}
+function renderedRouteCandidates(outDir, route) {
+    const relative = normalizeRoute(route).replace(/^\/+|\/+$/g, '');
+    if (!relative)
+        return [path.join(outDir, 'index.html')];
+    return [
+        path.join(outDir, relative, 'index.html'),
+        path.join(outDir, `${relative}.html`),
+    ];
+}
+function objectValuesDeep(value) {
+    const results = [];
+    const seen = new Set();
+    const walk = (entry) => {
+        if (entry === null || typeof entry !== 'object' || seen.has(entry))
+            return;
+        seen.add(entry);
+        if (Array.isArray(entry)) {
+            entry.forEach(walk);
+            return;
+        }
+        const record = entry;
+        results.push(record);
+        Object.values(record).forEach(walk);
+    };
+    walk(value);
+    return results;
+}
+function arrayProperty(record, key) {
+    return Array.isArray(record[key]) ? record[key] : undefined;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringProperty(record, key) {
+    return typeof record[key] === 'string' ? record[key] : undefined;
+}
+function resolveSourcePath(siteDir, source) {
+    if (path.isAbsolute(source))
+        return source;
+    return path.resolve(siteDir, source.replace(/^@site\//, ''));
+}
+function normalizeSourcePath(siteDir, source, documentId) {
+    const relative = path.relative(siteDir, source);
+    return relative.startsWith('..') || path.isAbsolute(relative)
+        ? `.generated/${slug(documentId)}/${path.basename(source)}`
+        : relative.replaceAll(path.sep, '/');
+}
+export function normalizeRoute(route) {
+    const pathname = route.split(/[?#]/)[0] || '/';
+    return `/${pathname.replace(/^\/+|\/+$/g, '')}${pathname === '/' ? '' : '/'}`;
+}
+function titleFromRoute(route) {
+    const segment = route
+        .replace(/^\/+|\/+$/g, '')
+        .split('/')
+        .at(-1) || 'Home';
+    return segment
+        .replace(/[-_]+/g, ' ')
+        .replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function slug(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function matchesAny(value, patterns) {
+    return patterns.some((pattern) => matchesRoutePattern(value, pattern));
+}
+export function matchesRoutePattern(route, pattern) {
+    const expression = pattern
+        .split('**')
+        .map((part) => part.split('*').map(escapeExpression).join('[^/]*'))
+        .join('.*');
+    return new RegExp(`^${expression}$`).test(route);
+}
+function escapeExpression(value) {
+    return value.replace(/[|\\{}()[\]^$+?.-]/g, '\\$&');
+}
+function compareCandidate(left, right) {
+    return left.order - right.order || compareStrings(left.id, right.id);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/html.d.ts

@@ -0,0 +1,22 @@
+import type { AssetCollector } from './assets.js';
+import type { Block } from './types.js';
+export type RenderedLinkSemantic = {
+    href: string;
+    text: string;
+};
+export declare function renderedHtmlToBlocks(input: {
+    html: string;
+    outDir: string;
+    baseUrl: string;
+    assets: AssetCollector;
+    selectors?: string[];
+    route: string;
+    strict?: boolean;
+}): Promise<{
+    title?: string;
+    blocks: Block[];
+}>;
+export declare function renderedHtmlLinkSemantics(input: {
+    html: string;
+    selectors?: string[];
+}): RenderedLinkSemantic[];

package/dist/html.js

@@ -0,0 +1,329 @@
+import path from 'node:path';
+import { load } from 'cheerio';
+export async function renderedHtmlToBlocks(input) {
+    const { $, root } = renderedContent(input.html, input.selectors);
+    const title = root.find('h1').first().text().trim() ||
+        $('title').text().split('|')[0]?.trim();
+    const blocks = await transformElements($, root.children().toArray(), {
+        ...input,
+        strict: input.strict !== false,
+    });
+    return {
+        ...(title ? { title } : {}),
+        blocks,
+    };
+}
+export function renderedHtmlLinkSemantics(input) {
+    const { $, root } = renderedContent(input.html, input.selectors);
+    const semantics = [];
+    for (const element of root.find('a[href]').toArray()) {
+        const anchor = $(element);
+        const href = anchor.attr('href') ?? '';
+        semantics.push({ href, text: normalizeVisibleText(anchor.text()) });
+    }
+    return semantics;
+}
+function renderedContent(html, selectors) {
+    const $ = load(html);
+    const contentSelectors = selectors ?? [
+        'main article .theme-doc-markdown',
+        'main article',
+        'main',
+    ];
+    let root = $('body');
+    for (const selector of contentSelectors) {
+        const candidate = $(selector).first();
+        if (candidate.length) {
+            root = candidate;
+            break;
+        }
+    }
+    root.find('nav, footer, script, style, .theme-doc-toc-mobile, .theme-doc-toc-desktop, .pagination-nav, .breadcrumbs').remove();
+    return { $, root };
+}
+async function transformElements($, nodes, context) {
+    const blocks = [];
+    for (const node of nodes) {
+        if (node.type === 'text') {
+            const value = $(node).text().trim();
+            if (value)
+                blocks.push({
+                    type: 'paragraph',
+                    inlines: [{ type: 'text', value }],
+                });
+            continue;
+        }
+        if (node.type !== 'tag')
+            continue;
+        const element = node;
+        const name = element.name.toLowerCase();
+        if (name === 'a') {
+            const href = $(element).attr('href');
+            const children = await transformElements($, element.children, context);
+            rejectMeaningfulEmptyAnchor($, element, href ?? '', children.length, context);
+            blocks.push(...(href
+                ? applyLinkToBlocks(children, href, context)
+                : children));
+            continue;
+        }
+        if (/^h[1-6]$/.test(name)) {
+            blocks.push({
+                type: 'heading',
+                level: Number(name.slice(1)),
+                inlines: transformInlines($, element.children, context),
+            });
+            continue;
+        }
+        if (name === 'p') {
+            const images = $(element).children('img');
+            if (images.length === 1 && $(element).text().trim() === '') {
+                blocks.push(await transformImage($, images.get(0), context));
+            }
+            else {
+                blocks.push({
+                    type: 'paragraph',
+                    inlines: transformInlines($, element.children, context),
+                });
+            }
+            continue;
+        }
+        if (name === 'pre') {
+            const code = $(element).find('code').first();
+            const language = classLanguage(code.attr('class'));
+            const value = code.length
+                ? code.text().replace(/\n$/, '')
+                : $(element).text().replace(/\n$/, '');
+            blocks.push(language === 'mermaid'
+                ? { type: 'mermaid', value }
+                : {
+                    type: 'code',
+                    ...(language ? { language } : {}),
+                    value,
+                });
+            continue;
+        }
+        if (name === 'ul' || name === 'ol') {
+            const items = [];
+            for (const item of $(element).children('li').toArray()) {
+                const childBlocks = await transformElements($, item.children, context);
+                items.push(childBlocks.length
+                    ? childBlocks
+                    : [
+                        {
+                            type: 'paragraph',
+                            inlines: transformInlines($, item.children, context),
+                        },
+                    ]);
+            }
+            blocks.push({ type: 'list', ordered: name === 'ol', items });
+            continue;
+        }
+        if (name === 'table') {
+            const rows = $(element)
+                .find('tr')
+                .toArray()
+                .map((row) => $(row)
+                .children('th,td')
+                .toArray()
+                .map((cell) => transformInlines($, cell.children, context)));
+            blocks.push({
+                type: 'table',
+                header: rows[0] ?? [],
+                rows: rows.slice(1),
+            });
+            continue;
+        }
+        if (name === 'img') {
+            blocks.push(await transformImage($, element, context));
+            continue;
+        }
+        if (name === 'hr') {
+            blocks.push({ type: 'thematicBreak' });
+            continue;
+        }
+        const className = $(element).attr('class') ?? '';
+        if (name === 'blockquote' || className.split(/\s+/).includes('alert')) {
+            const alertKind = className.match(/alert--([\w-]+)/)?.[1];
+            blocks.push({
+                type: 'admonition',
+                kind: name === 'blockquote' ? 'quote' : (alertKind ?? 'note'),
+                blocks: await transformElements($, element.children, context),
+            });
+            continue;
+        }
+        blocks.push(...(await transformElements($, element.children, context)));
+    }
+    return blocks.filter((block) => block.type !== 'paragraph' || block.inlines.length > 0);
+}
+function applyLinkToBlocks(blocks, href, context) {
+    return blocks.map((block) => applyLinkToBlock(block, href, context));
+}
+function applyLinkToBlock(block, href, context) {
+    switch (block.type) {
+        case 'paragraph':
+        case 'heading':
+            if (containsLink(block.inlines))
+                return unsupportedLinkedBlock(block, href, context, 'nested link');
+            return {
+                ...block,
+                inlines: block.inlines.length === 0
+                    ? block.inlines
+                    : [
+                        {
+                            type: 'link',
+                            target: { kind: 'url', value: href },
+                            children: block.inlines,
+                        },
+                    ],
+            };
+        case 'list':
+            return {
+                ...block,
+                items: block.items.map((item) => applyLinkToBlocks(item, href, context)),
+            };
+        case 'admonition':
+            return {
+                ...block,
+                blocks: applyLinkToBlocks(block.blocks, href, context),
+            };
+        case 'table':
+        case 'code':
+        case 'mermaid':
+        case 'image':
+        case 'thematicBreak':
+        case 'extension':
+            return unsupportedLinkedBlock(block, href, context, 'unsupported block semantics');
+        default:
+            return assertNever(block);
+    }
+}
+function unsupportedLinkedBlock(block, href, context, reason) {
+    rejectUnsupportedLink(context, href, reason, block.type);
+    return block;
+}
+function rejectUnsupportedLink(context, href, reason, blockType) {
+    if (!context.strict)
+        return;
+    throw new Error(`cannot preserve block link on route ${context.route} for href ${href}: ${reason} for block type ${blockType}`);
+}
+function containsLink(inlines) {
+    return inlines.some((inline) => inline.type === 'link');
+}
+function assertNever(value) {
+    throw new Error(`unsupported rendered block: ${JSON.stringify(value)}`);
+}
+function transformInlines($, nodes, context, marks = []) {
+    const result = [];
+    for (const node of nodes) {
+        if (node.type === 'text') {
+            result.push({
+                type: 'text',
+                value: $(node).text(),
+                ...(marks.length ? { marks: [...marks].sort() } : {}),
+            });
+            continue;
+        }
+        if (node.type !== 'tag')
+            continue;
+        const element = node;
+        const name = element.name.toLowerCase();
+        if (name === 'strong' || name === 'b')
+            result.push(...transformInlines($, element.children, context, [
+                ...marks,
+                'bold',
+            ]));
+        else if (name === 'em' || name === 'i')
+            result.push(...transformInlines($, element.children, context, [
+                ...marks,
+                'italic',
+            ]));
+        else if (name === 'del' || name === 's')
+            result.push(...transformInlines($, element.children, context, [
+                ...marks,
+                'strikethrough',
+            ]));
+        else if (name === 'code')
+            result.push(...transformInlines($, element.children, context, [
+                ...marks,
+                'code',
+            ]));
+        else if (name === 'a') {
+            const href = $(element).attr('href') ?? '';
+            if ($(element).find('img').length > 0)
+                rejectUnsupportedLink(context, href, 'unsupported block semantics', 'image');
+            const children = transformInlines($, element.children, context, marks);
+            rejectMeaningfulEmptyAnchor($, element, href, children.length, context);
+            result.push({
+                type: 'link',
+                target: { kind: 'url', value: href },
+                children,
+            });
+        }
+        else if (name === 'br')
+            result.push({ type: 'text', value: '\n' });
+        else
+            result.push(...transformInlines($, element.children, context, marks));
+    }
+    return mergeText(result);
+}
+function rejectMeaningfulEmptyAnchor($, element, href, outputLength, context) {
+    if (outputLength > 0)
+        return;
+    const anchor = $(element);
+    const hasAccessibleText = Boolean(anchor.attr('aria-label')?.trim()) ||
+        Boolean(anchor.attr('title')?.trim()) ||
+        anchor.find('[aria-label], [title], [alt]').length > 0;
+    const hasMeaningfulDescendant = element.children.some((child) => child.type === 'tag' || $(child).text().trim().length > 0);
+    if (!hasAccessibleText && !hasMeaningfulDescendant)
+        return;
+    rejectUnsupportedLink(context, href, 'unsupported inline semantics', 'extension');
+}
+function normalizeVisibleText(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+async function transformImage($, element, context) {
+    const source = $(element).attr('src') ?? '';
+    if (/^(?:https?:)?\/\//.test(source) || source.startsWith('data:')) {
+        return {
+            type: 'extension',
+            name: 'remoteImage',
+            data: { url: source, alt: $(element).attr('alt') },
+        };
+    }
+    const withoutQuery = source.split(/[?#]/)[0] ?? source;
+    const basePrefix = `/${context.baseUrl.replace(/^\/+|\/+$/g, '')}/`.replace('//', '/');
+    const relative = withoutQuery.startsWith(basePrefix)
+        ? withoutQuery.slice(basePrefix.length)
+        : withoutQuery.replace(/^\/+/, '');
+    const absolute = path.resolve(context.outDir, relative);
+    const outputRelative = path.relative(path.resolve(context.outDir), absolute);
+    if (outputRelative.startsWith('..') || path.isAbsolute(outputRelative)) {
+        throw new Error(`rendered asset escapes the Docusaurus output directory: ${source}`);
+    }
+    const assetId = await context.assets.add(absolute);
+    return {
+        type: 'image',
+        assetId,
+        ...($(element).attr('alt') ? { alt: $(element).attr('alt') } : {}),
+        ...($(element).attr('title')
+            ? { title: $(element).attr('title') }
+            : {}),
+    };
+}
+function classLanguage(className) {
+    return className?.match(/(?:^|\s)language-([\w-]+)/)?.[1];
+}
+function mergeText(inlines) {
+    const result = [];
+    for (const inline of inlines) {
+        const previous = result.at(-1);
+        if (inline.type === 'text' &&
+            previous?.type === 'text' &&
+            JSON.stringify(inline.marks ?? []) ===
+                JSON.stringify(previous.marks ?? []))
+            previous.value += inline.value;
+        else
+            result.push(inline);
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './plugin.js';
+export { contentHash, canonicalJson } from './canonical.js';
+export { defineComponentHandler } from './types.js';
+export type { Block, BundleAsset, BundleDocument, BundleSource, ComponentHandler, ComponentHandlerAssetInput, ComponentHandlerContext, ComponentHandlerRegistration, DocumentBundle, Inline, LinkInline, MdxAstNode, PluginOptions, TextInline, TextMark, } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default } from './plugin.js';
+export { contentHash, canonicalJson } from './canonical.js';
+export { defineComponentHandler } from './types.js';