@tanstack/markdown 0.0.1

package/README.md

@@ -0,0 +1,36 @@
+# TanStack Markdown
+
+A tiny deterministic TanStack-flavored Markdown renderer.
+
+```bash
+pnpm add @tanstack/markdown
+```
+
+## Commands
+
+```bash
+pnpm test
+pnpm run typecheck
+pnpm run build
+pnpm run research
+```
+
+## Entry Points
+
+- `src/parser.ts`: Markdown subset parser to a serializable AST
+- `src/html.ts`: HTML string renderer
+- `src/react.ts`: React adapter
+- `src/extensions/*`: optional docs-site extension functions
+- `scripts/measure-size.ts`: bundle size matrix
+- `scripts/bench.ts`: CPU benchmark matrix
+
+## Reports
+
+- [Bundle sizes](./reports/sizes.md)
+- [Benchmarks](./reports/benchmarks.md)
+- [Audit](./docs/audit.md)
+- [Spec and API](./docs/spec.md)
+- [Goal and coverage map](./docs/goal.md)
+- [Bundle strategy](./docs/bundle-strategy.md)
+- [Extensions](./docs/extensions.md)
+- [Recommendation](./docs/recommendation.md)

package/dist/extensions/callouts.d.ts

@@ -0,0 +1,4 @@
+import type { CalloutNode, MarkdownExtension } from '../types.js';
+export declare function calloutsExtension(): MarkdownExtension;
+export declare function parseCalloutBlock(context: Parameters<NonNullable<MarkdownExtension['parseBlock']>>[0]): CalloutNode | undefined;
+//# sourceMappingURL=callouts.d.ts.map

package/dist/extensions/callouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callouts.d.ts","sourceRoot":"","sources":["../../src/extensions/callouts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEjE,wBAAgB,iBAAiB,IAAI,iBAAiB,CAKrD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,GAAG,SAAS,CA+B/H"}

package/dist/extensions/callouts.js

@@ -0,0 +1,39 @@
+export function calloutsExtension() {
+    return {
+        name: 'callouts',
+        parseBlock: parseCalloutBlock,
+    };
+}
+export function parseCalloutBlock(context) {
+    const first = context.lines[context.index] ?? '';
+    const match = first.match(/^ {0,3}>\s*\[!([A-Za-z]+)\](?:\s+(.*))?$/);
+    if (!match)
+        return undefined;
+    const kind = match[1].toLowerCase();
+    const title = match[2]?.trim() || titleCase(kind);
+    const body = [];
+    let cursor = context.index + 1;
+    while (cursor < context.lines.length) {
+        const line = context.lines[cursor] ?? '';
+        if (/^\s*$/.test(line)) {
+            body.push('');
+            cursor++;
+            continue;
+        }
+        const quoted = line.match(/^ {0,3}>\s?(.*)$/);
+        if (!quoted)
+            break;
+        body.push(quoted[1]);
+        cursor++;
+    }
+    context.consume(cursor - context.index);
+    return {
+        type: 'callout',
+        kind,
+        title,
+        children: context.parseBlocks(body.join('\n')),
+    };
+}
+function titleCase(value) {
+    return value.slice(0, 1).toUpperCase() + value.slice(1).toLowerCase();
+}

package/dist/extensions/comment-components.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentNode, MarkdownExtension } from '../types.js';
+export interface CommentComponentOptions {
+    transformComponent?: (node: ComponentNode) => ComponentNode;
+}
+export interface ComponentComment {
+    block: boolean;
+    name: string;
+    attributes: Record<string, string>;
+}
+export declare function commentComponentsExtension(options?: CommentComponentOptions): MarkdownExtension;
+export declare function parseCommentComponentBlock(context: Parameters<NonNullable<MarkdownExtension['parseBlock']>>[0], options?: CommentComponentOptions): ComponentNode | undefined;
+export declare function parseComponentComment(line: string): ComponentComment | undefined;
+export declare function parseAttributes(value: string): Record<string, string>;
+//# sourceMappingURL=comment-components.d.ts.map

package/dist/extensions/comment-components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment-components.d.ts","sourceRoot":"","sources":["../../src/extensions/comment-components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEnE,MAAM,WAAW,uBAAuB;IACtC,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,aAAa,CAAA;CAC5D;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,uBAA4B,GAAG,iBAAiB,CAKnG;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EACpE,OAAO,GAAE,uBAA4B,GACpC,aAAa,GAAG,SAAS,CA2C3B;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAQhF;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOrE"}

package/dist/extensions/comment-components.js

@@ -0,0 +1,68 @@
+export function commentComponentsExtension(options = {}) {
+    return {
+        name: 'comment-components',
+        parseBlock: context => parseCommentComponentBlock(context, options),
+    };
+}
+export function parseCommentComponentBlock(context, options = {}) {
+    const line = context.lines[context.index] ?? '';
+    const start = parseComponentComment(line);
+    if (!start)
+        return undefined;
+    if (!start.block) {
+        context.consume(1);
+        return transform({
+            type: 'component',
+            name: start.name,
+            attributes: start.attributes,
+            children: [],
+        }, options);
+    }
+    const body = [];
+    let cursor = context.index + 1;
+    let foundEnd = false;
+    while (cursor < context.lines.length) {
+        const candidate = context.lines[cursor] ?? '';
+        if (isEndComment(candidate, start.name)) {
+            foundEnd = true;
+            cursor++;
+            break;
+        }
+        body.push(candidate);
+        cursor++;
+    }
+    context.consume(foundEnd ? cursor - context.index : 1);
+    return transform({
+        type: 'component',
+        name: start.name,
+        attributes: start.attributes,
+        children: foundEnd ? context.parseBlocks(body.join('\n')) : [],
+    }, options);
+}
+export function parseComponentComment(line) {
+    const match = line.match(/^ {0,3}<!--\s*::(start:)?([A-Za-z][\w-]*)(.*?)\s*-->\s*$/);
+    if (!match)
+        return undefined;
+    return {
+        block: Boolean(match[1]),
+        name: match[2].toLowerCase(),
+        attributes: parseAttributes(match[3] ?? ''),
+    };
+}
+export function parseAttributes(value) {
+    const attrs = {};
+    const regex = /([A-Za-z_][\w:-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\s"']+)))?/g;
+    for (const match of value.matchAll(regex)) {
+        attrs[match[1]] = match[2] ?? match[3] ?? match[4] ?? 'true';
+    }
+    return attrs;
+}
+function transform(node, options) {
+    return options.transformComponent?.(node) ?? node;
+}
+function isEndComment(line, name) {
+    return new RegExp(`^ {0,3}<!--\\s*::end:${escapeRegex(name)}\\s*-->\\s*$`, 'i').test(line);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/extensions/docs.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentNode, MarkdownExtension } from '../types.js';
+import { type HeadingCollectionOptions } from './headings.js';
+export interface DocsMarkdownOptions {
+    collectHeadings?: boolean | HeadingCollectionOptions;
+}
+export declare function docsMarkdownExtensions(options?: DocsMarkdownOptions): MarkdownExtension[];
+export declare function transformDocsComponent(node: ComponentNode): ComponentNode;
+//# sourceMappingURL=docs.d.ts.map

package/dist/extensions/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/extensions/docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAInE,OAAO,EAA8B,KAAK,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAGzF,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,OAAO,GAAG,wBAAwB,CAAA;CACrD;AAED,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,mBAAwB,GAAG,iBAAiB,EAAE,CAiB7F;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAKzE"}

package/dist/extensions/docs.js

@@ -0,0 +1,25 @@
+import { calloutsExtension } from './callouts.js';
+import { commentComponentsExtension } from './comment-components.js';
+import { transformFrameworkComponent } from './framework.js';
+import { headingCollectionExtension } from './headings.js';
+import { transformTabsComponent } from './tabs.js';
+export function docsMarkdownExtensions(options = {}) {
+    const extensions = [
+        calloutsExtension(),
+        commentComponentsExtension({
+            transformComponent: transformDocsComponent,
+        }),
+    ];
+    if (options.collectHeadings !== false) {
+        extensions.push(headingCollectionExtension(typeof options.collectHeadings === 'object' ? options.collectHeadings : {}));
+    }
+    return extensions;
+}
+export function transformDocsComponent(node) {
+    const name = node.name.toLowerCase();
+    if (name === 'tabs')
+        return transformTabsComponent(node);
+    if (name === 'framework')
+        return transformFrameworkComponent(node);
+    return node;
+}

package/dist/extensions/framework.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentNode } from '../types.js';
+export declare function transformFrameworkComponent(node: ComponentNode): ComponentNode;
+//# sourceMappingURL=framework.d.ts.map

package/dist/extensions/framework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.d.ts","sourceRoot":"","sources":["../../src/extensions/framework.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3D,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAyC9E"}

package/dist/extensions/framework.js

@@ -0,0 +1,40 @@
+import { markFrameworkHeadings, splitByHeading } from './shared.js';
+export function transformFrameworkComponent(node) {
+    const sections = splitByHeading(node.children, 1);
+    if (!sections.length)
+        return node;
+    const frameworks = sections.map(section => section.name.toLowerCase());
+    const panels = sections.map((section) => {
+        const framework = section.name.toLowerCase();
+        return {
+            type: 'component',
+            name: 'framework-panel',
+            tagName: 'md-framework-panel',
+            attributes: {},
+            properties: {
+                'data-framework': framework,
+            },
+            children: markFrameworkHeadings(section.children, framework),
+        };
+    });
+    return {
+        ...node,
+        properties: {
+            ...(node.properties ?? {}),
+            'data-available-frameworks': JSON.stringify(frameworks),
+            'data-framework-meta': JSON.stringify({
+                codeBlocksByFramework: Object.fromEntries(sections.map(section => [
+                    section.name.toLowerCase(),
+                    section.children
+                        .filter((child) => child.type === 'code')
+                        .map(child => ({
+                        title: child.title ?? '',
+                        code: child.value,
+                        language: child.lang ?? 'plaintext',
+                    })),
+                ])),
+            }),
+        },
+        children: panels,
+    };
+}

package/dist/extensions/headings.d.ts

@@ -0,0 +1,7 @@
+import type { MarkdownDocument, MarkdownExtension, MarkdownHeading } from '../types.js';
+export interface HeadingCollectionOptions {
+    skipComponentNames?: ReadonlySet<string> | string[];
+}
+export declare function headingCollectionExtension(options?: HeadingCollectionOptions): MarkdownExtension;
+export declare function collectMarkdownHeadings(document: MarkdownDocument, options?: HeadingCollectionOptions): MarkdownHeading[];
+//# sourceMappingURL=headings.d.ts.map

package/dist/extensions/headings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headings.d.ts","sourceRoot":"","sources":["../../src/extensions/headings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAGlG,MAAM,WAAW,wBAAwB;IACvC,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAAA;CACpD;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,wBAA6B,GAAG,iBAAiB,CAUpG;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,GAAE,wBAA6B,GAAG,eAAe,EAAE,CAK7H"}

package/dist/extensions/headings.js

@@ -0,0 +1,51 @@
+import { plainText } from '../utils.js';
+export function headingCollectionExtension(options = {}) {
+    return {
+        name: 'heading-collection',
+        transformDocument(document) {
+            return {
+                ...document,
+                headings: collectMarkdownHeadings(document, options),
+            };
+        },
+    };
+}
+export function collectMarkdownHeadings(document, options = {}) {
+    const headings = [];
+    const skip = new Set(options.skipComponentNames ?? ['tabs']);
+    collectFromBlocks(document.children, headings, undefined, false, skip);
+    return headings;
+}
+function collectFromBlocks(blocks, headings, framework, insideSkippedComponent, skipComponentNames) {
+    for (const block of blocks) {
+        if (block.type === 'heading') {
+            if (!insideSkippedComponent && block.id) {
+                const heading = {
+                    id: block.id,
+                    text: plainText(block.children),
+                    level: block.depth,
+                };
+                const headingFramework = block.framework ?? framework;
+                if (headingFramework)
+                    heading.framework = headingFramework;
+                headings.push(heading);
+            }
+            continue;
+        }
+        if (block.type === 'list') {
+            for (const item of block.items)
+                collectFromBlocks(item.children, headings, framework, insideSkippedComponent, skipComponentNames);
+            continue;
+        }
+        if (block.type === 'blockquote' || block.type === 'callout') {
+            collectFromBlocks(block.children, headings, framework, insideSkippedComponent, skipComponentNames);
+            continue;
+        }
+        if (block.type === 'component') {
+            const name = block.name.toLowerCase();
+            const nextInsideSkippedComponent = insideSkippedComponent || skipComponentNames.has(name);
+            const nextFramework = block.tagName === 'md-framework-panel' ? block.properties?.['data-framework'] ?? framework : framework;
+            collectFromBlocks(block.children, headings, nextFramework, nextInsideSkippedComponent, skipComponentNames);
+        }
+    }
+}

package/dist/extensions/shared.d.ts

@@ -0,0 +1,12 @@
+import type { BlockNode, ComponentNode } from '../types.js';
+export interface HeadingSection {
+    id?: string;
+    name: string;
+    children: BlockNode[];
+}
+export declare function blocksToText(blocks: BlockNode[]): string;
+export declare function splitByHeading(children: BlockNode[], forcedDepth?: number): HeadingSection[];
+export declare function slugify(value: string, fallback: string): string;
+export declare function markFrameworkHeadings(blocks: BlockNode[], framework: string): BlockNode[];
+export declare function getComponentName(node: ComponentNode): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/extensions/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/extensions/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAe,MAAM,aAAa,CAAA;AAGxE,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,SAAS,EAAE,CAAA;CACtB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAsBxD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE,CAsB5F;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAWtD;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAmCzF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,UAEnD"}

package/dist/extensions/shared.js

@@ -0,0 +1,92 @@
+import { plainText } from '../utils.js';
+export function blocksToText(blocks) {
+    return blocks
+        .map(block => {
+        switch (block.type) {
+            case 'paragraph':
+            case 'heading':
+                return plainText(block.children);
+            case 'code':
+                return block.value;
+            case 'list':
+                return block.items.map(item => blocksToText(item.children)).join('\n');
+            case 'blockquote':
+            case 'callout':
+            case 'component':
+                return blocksToText(block.children);
+            case 'table':
+                return [block.header, ...block.rows].map(row => row.map(cell => plainText(cell.children)).join(' ')).join('\n');
+            default:
+                return '';
+        }
+    })
+        .join('\n');
+}
+export function splitByHeading(children, forcedDepth) {
+    const headings = children.filter((child) => child.type === 'heading');
+    const depth = forcedDepth ?? Math.min(...headings.map(heading => heading.depth));
+    if (!Number.isFinite(depth))
+        return [];
+    const sections = [];
+    let current;
+    for (const child of children) {
+        if (child.type === 'heading' && child.depth === depth) {
+            current = {
+                name: plainText(child.children),
+                children: [],
+            };
+            if (child.id)
+                current.id = child.id;
+            sections.push(current);
+            continue;
+        }
+        if (current)
+            current.children.push(child);
+    }
+    return sections;
+}
+export function slugify(value, fallback) {
+    return (value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 64) || fallback);
+}
+export function markFrameworkHeadings(blocks, framework) {
+    return blocks.map(block => {
+        if (block.type === 'heading' && block.depth > 1) {
+            return {
+                ...block,
+                framework,
+            };
+        }
+        if (block.type === 'blockquote' || block.type === 'callout') {
+            return {
+                ...block,
+                children: markFrameworkHeadings(block.children, framework),
+            };
+        }
+        if (block.type === 'list') {
+            return {
+                ...block,
+                items: block.items.map(item => ({
+                    ...item,
+                    children: markFrameworkHeadings(item.children, framework),
+                })),
+            };
+        }
+        if (block.type === 'component') {
+            return {
+                ...block,
+                children: markFrameworkHeadings(block.children, framework),
+            };
+        }
+        return block;
+    });
+}
+export function getComponentName(node) {
+    return node.name.toLowerCase();
+}

package/dist/extensions/tabs.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentNode } from '../types.js';
+export declare function transformTabsComponent(node: ComponentNode): ComponentNode;
+export declare function transformFileTabs(node: ComponentNode): ComponentNode;
+export declare function transformPackageManagerTabs(node: ComponentNode): ComponentNode;
+export declare function transformBundlerTabs(node: ComponentNode): ComponentNode;
+export declare function transformHeadingTabs(node: ComponentNode): ComponentNode;
+//# sourceMappingURL=tabs.d.ts.map

package/dist/extensions/tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.d.ts","sourceRoot":"","sources":["../../src/extensions/tabs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,aAAa,CAAA;AAK3D,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAQzE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAkCpE;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CA4B9E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAiCvE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CA2BvE"}

package/dist/extensions/tabs.js

@@ -0,0 +1,145 @@
+import { blocksToText, slugify, splitByHeading } from './shared.js';
+const bundlers = ['vite', 'rsbuild'];
+export function transformTabsComponent(node) {
+    const variant = node.attributes.variant?.toLowerCase();
+    if (variant === 'files')
+        return transformFileTabs(node);
+    if (variant === 'package-manager' || variant === 'package-managers')
+        return transformPackageManagerTabs(node);
+    if (variant === 'bundler')
+        return transformBundlerTabs(node);
+    return transformHeadingTabs(node);
+}
+export function transformFileTabs(node) {
+    const files = node.children.filter((child) => child.type === 'code');
+    if (!files.length)
+        return node;
+    const tabs = files.map((file, index) => ({
+        slug: `file-${index}`,
+        name: file.title || file.file || 'Untitled',
+    }));
+    return {
+        ...node,
+        properties: {
+            ...(node.properties ?? {}),
+            'data-attributes': JSON.stringify({ tabs }),
+            'data-files-meta': JSON.stringify({
+                files: files.map(file => ({
+                    title: file.title || file.file || 'Untitled',
+                    code: file.value,
+                    language: file.lang ?? 'plaintext',
+                })),
+            }),
+        },
+        children: files.map((file, index) => ({
+            type: 'component',
+            name: 'tab-panel',
+            tagName: 'md-tab-panel',
+            attributes: {},
+            properties: {
+                'data-tab-slug': `file-${index}`,
+                'data-tab-index': String(index),
+            },
+            children: [file],
+        })),
+    };
+}
+export function transformPackageManagerTabs(node) {
+    const packagesByFramework = {};
+    for (const line of blocksToText(node.children).split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const colon = trimmed.indexOf(':');
+        if (colon === -1)
+            continue;
+        const framework = trimmed.slice(0, colon).trim().toLowerCase();
+        const packages = trimmed.slice(colon + 1).trim().split(/\s+/).filter(Boolean);
+        if (!framework || packages.length === 0)
+            continue;
+        packagesByFramework[framework] ??= [];
+        packagesByFramework[framework].push(packages);
+    }
+    if (!Object.keys(packagesByFramework).length)
+        return node;
+    return {
+        ...node,
+        properties: {
+            ...(node.properties ?? {}),
+            'data-package-manager-meta': JSON.stringify({
+                packagesByFramework,
+                mode: resolveInstallMode(node.attributes.mode),
+            }),
+        },
+        children: [],
+    };
+}
+export function transformBundlerTabs(node) {
+    const sections = splitByHeading(node.children);
+    const selected = sections.filter(section => isBundler(section.name.toLowerCase()));
+    if (!selected.length)
+        return node;
+    const tabs = bundlers
+        .map(bundler => selected.find(section => section.name.toLowerCase() === bundler))
+        .filter((section) => Boolean(section))
+        .map(section => ({ slug: section.name.toLowerCase(), name: section.name.toLowerCase() }));
+    return {
+        ...node,
+        properties: {
+            ...(node.properties ?? {}),
+            'data-attributes': JSON.stringify({ tabs }),
+            'data-bundler-meta': JSON.stringify({ bundlers: tabs.map(tab => tab.slug) }),
+        },
+        children: tabs.map((tab, index) => {
+            const section = selected.find(section => section.name.toLowerCase() === tab.slug);
+            return {
+                type: 'component',
+                name: 'tab-panel',
+                tagName: 'md-tab-panel',
+                attributes: {},
+                properties: {
+                    'data-tab-slug': tab.slug,
+                    'data-tab-index': String(index),
+                    'data-content': section.children.length === 1 && section.children[0]?.type === 'code' ? 'code-only' : 'mixed',
+                },
+                children: section.children,
+            };
+        }),
+    };
+}
+export function transformHeadingTabs(node) {
+    const sections = splitByHeading(node.children);
+    if (!sections.length)
+        return node;
+    const tabs = sections.map((section, index) => ({
+        slug: section.id || slugify(section.name, `tab-${index + 1}`),
+        name: section.name,
+    }));
+    return {
+        ...node,
+        properties: {
+            ...(node.properties ?? {}),
+            'data-attributes': JSON.stringify({ tabs }),
+        },
+        children: sections.map((section, index) => ({
+            type: 'component',
+            name: 'tab-panel',
+            tagName: 'md-tab-panel',
+            attributes: {},
+            properties: {
+                'data-tab-slug': tabs[index]?.slug ?? `tab-${index + 1}`,
+                'data-tab-index': String(index),
+            },
+            children: section.children,
+        })),
+    };
+}
+function resolveInstallMode(value) {
+    const mode = value?.toLowerCase();
+    if (mode === 'dev-install' || mode === 'local-install')
+        return mode;
+    return 'install';
+}
+function isBundler(value) {
+    return bundlers.includes(value);
+}

package/dist/html.d.ts

@@ -0,0 +1,6 @@
+import type { BlockNode, InlineNode, MarkdownDocument, MarkdownInput, RenderOptions } from './types.js';
+export declare function renderHtml(input: MarkdownInput, options?: RenderOptions): string;
+export declare function renderBlock(node: BlockNode, options?: RenderOptions): string;
+export declare function renderInline(node: InlineNode, options?: RenderOptions): string;
+export declare function renderDocument(document: MarkdownDocument, options?: RenderOptions): string;
+//# sourceMappingURL=html.d.ts.map

package/dist/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAuC,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAA;AAG3J,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAGpF;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CA8ChF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAwBlF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAE9F"}