astro-xmdx 0.0.2

package/src/transforms/expressive-code.test.ts

@@ -0,0 +1,274 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  decodeHtmlEntities,
+  rewriteExpressiveCodeBlocks,
+  rewriteSetHtmlCodeBlocks,
+  injectExpressiveCodeComponent,
+} from './expressive-code.js';
+
+describe('decodeHtmlEntities', () => {
+  test('returns value as-is when empty', () => {
+    expect(decodeHtmlEntities('')).toBe('');
+  });
+
+  test('returns value as-is when no entities present', () => {
+    expect(decodeHtmlEntities('hello world')).toBe('hello world');
+  });
+
+  test('decodes hex entities', () => {
+    expect(decodeHtmlEntities('A')).toBe('A');
+    expect(decodeHtmlEntities('&#x3c;div&#x3e;')).toBe('<div>');
+  });
+
+  test('decodes decimal entities', () => {
+    expect(decodeHtmlEntities('&#65;')).toBe('A');
+    expect(decodeHtmlEntities('&#60;div&#62;')).toBe('<div>');
+  });
+
+  test('decodes named entities', () => {
+    expect(decodeHtmlEntities('&quot;hello&quot;')).toBe('"hello"');
+    expect(decodeHtmlEntities("&#39;world&#39;")).toBe("'world'");
+    expect(decodeHtmlEntities('&lt;div&gt;')).toBe('<div>');
+    expect(decodeHtmlEntities('&amp;')).toBe('&');
+  });
+
+  test('decodes mixed entities', () => {
+    expect(decodeHtmlEntities('&lt;div&#x3e;&#65;&amp;&quot;')).toBe(
+      '<div>A&"'
+    );
+  });
+
+  test('decodes multiple occurrences', () => {
+    expect(decodeHtmlEntities('&lt;&lt;&lt;')).toBe('<<<');
+    expect(decodeHtmlEntities('&#x41;&#x42;&#x43;')).toBe('ABC');
+  });
+
+  test('handles ampersand correctly (decoded last)', () => {
+    expect(decodeHtmlEntities('&amp;lt;')).toBe('&lt;');
+  });
+});
+
+describe('rewriteExpressiveCodeBlocks', () => {
+  test('returns unchanged code when no code blocks', () => {
+    const code = '# Hello\n\nSome text';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe(code);
+    expect(result.changed).toBe(false);
+  });
+
+  test('rewrites simple code block without language', () => {
+    const code = '<pre><code>const x = 1;</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"const x = 1;"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('rewrites code block with language', () => {
+    const code = '<pre><code class="language-javascript">const x = 1;</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe(
+      '<Code code={"const x = 1;"} lang="javascript" />'
+    );
+    expect(result.changed).toBe(true);
+  });
+
+  test('rewrites multiple code blocks', () => {
+    const code =
+      '<pre><code class="language-js">let a = 1;</code></pre>\n\n<pre><code class="language-ts">let b: number = 2;</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe(
+      '<Code code={"let a = 1;"} lang="js" />\n\n<Code code={"let b: number = 2;"} lang="ts" />'
+    );
+    expect(result.changed).toBe(true);
+  });
+
+  test('decodes HTML entities in code content', () => {
+    const code = '<pre><code>&lt;div&gt;&amp;&lt;/div&gt;</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"<div>&</div>"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('uses custom component name', () => {
+    const code = '<pre><code>hello</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'MyCode');
+    expect(result.code).toBe('<MyCode code={"hello"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('handles multiline code', () => {
+    const code = '<pre><code>line 1\nline 2\nline 3</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"line 1\\nline 2\\nline 3"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('preserves code with special characters', () => {
+    const code = '<pre><code>const str = "hello";</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"const str = \\"hello\\";"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('handles pre tag with attributes', () => {
+    const code = '<pre class="astro-code" tabindex="0"><code class="language-sh"># create a new project\nnpm create astro@latest</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"# create a new project\\nnpm create astro@latest"} lang="sh" />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('handles pre tag with single attribute', () => {
+    const code = '<pre tabindex="0"><code>simple code</code></pre>';
+    const result = rewriteExpressiveCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"simple code"} />');
+    expect(result.changed).toBe(true);
+  });
+});
+
+describe('rewriteSetHtmlCodeBlocks', () => {
+  test('returns unchanged when no Fragment marker found', () => {
+    const code = '<div><p>Hello</p></div>';
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe(code);
+    expect(result.changed).toBe(false);
+  });
+
+  test('returns unchanged when no code blocks inside Fragment', () => {
+    const code = '<_Fragment set:html={"<p>Hello world</p>"} />';
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe(code);
+    expect(result.changed).toBe(false);
+  });
+
+  test('rewrites code block inside Fragment', () => {
+    const code = '<_Fragment set:html={"<pre><code>const x = 1;</code></pre>"} />';
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"const x = 1;"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('rewrites code block with language inside Fragment', () => {
+    const html = '<pre><code class="language-js">let a = 1;</code></pre>';
+    const code = `<_Fragment set:html={${JSON.stringify(html)}} />`;
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"let a = 1;"} lang="js" />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('processes multiple Fragment occurrences', () => {
+    const code = `
+      <_Fragment set:html={"<pre><code>first</code></pre>"} />
+      <_Fragment set:html={"<pre><code>second</code></pre>"} />
+    `;
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toContain('<Code code={"first"} />');
+    expect(result.code).toContain('<Code code={"second"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('preserves surrounding JSX', () => {
+    const code = `
+      <SplitCard>
+        <_Fragment set:html={"<pre><code>npm install</code></pre>"} />
+      </SplitCard>
+    `;
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toContain('<SplitCard>');
+    expect(result.code).toContain('</SplitCard>');
+    expect(result.code).toContain('<Code code={"npm install"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('uses custom component name', () => {
+    const code = '<_Fragment set:html={"<pre><code>test</code></pre>"} />';
+    const result = rewriteSetHtmlCodeBlocks(code, 'MyCodeBlock');
+    expect(result.code).toBe('<MyCodeBlock code={"test"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('handles JSON with escaped quotes', () => {
+    const html = '<pre><code>const str = "hello";</code></pre>';
+    const code = `<_Fragment set:html={${JSON.stringify(html)}} />`;
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe('<Code code={"const str = \\"hello\\";"} />');
+    expect(result.changed).toBe(true);
+  });
+
+  test('skips invalid JSON', () => {
+    const code = '<_Fragment set:html={not valid json} />';
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    expect(result.code).toBe(code);
+    expect(result.changed).toBe(false);
+  });
+
+  test('handles mixed HTML and code - keeps Fragment for mixed content', () => {
+    const html = '<p>text</p><pre><code>hello</code></pre>';
+    const code = `<_Fragment set:html={${JSON.stringify(html)}} />`;
+    const result = rewriteSetHtmlCodeBlocks(code, 'Code');
+    // When there's mixed content, the code block is replaced inline
+    expect(result.code).toContain('<Code code={"hello"} />');
+    expect(result.changed).toBe(true);
+  });
+});
+
+describe('injectExpressiveCodeComponent', () => {
+  test('does not inject if already imported', () => {
+    const code = `import { Code } from 'astro-expressive-code';\n\n# Hello`;
+    const config = { component: 'Code', moduleId: 'astro-expressive-code' };
+    const result = injectExpressiveCodeComponent(code, config);
+    expect(result).toBe(code);
+  });
+
+  test('injects default Code import', () => {
+    const code = `import { useState } from 'react';\n\n# Hello`;
+    const config = {
+      component: 'Code',
+      moduleId: 'astro-expressive-code/components',
+    };
+    const result = injectExpressiveCodeComponent(code, config);
+    expect(result).toContain(
+      `import { Code } from 'astro-expressive-code/components';`
+    );
+    expect(result).toContain(`import { useState } from 'react';`);
+  });
+
+  test('injects aliased Code import for custom component name', () => {
+    const code = `import { useState } from 'react';\n\n# Hello`;
+    const config = {
+      component: 'MyCode',
+      moduleId: 'astro-expressive-code/components',
+    };
+    const result = injectExpressiveCodeComponent(code, config);
+    expect(result).toContain(
+      `import { Code as MyCode } from 'astro-expressive-code/components';`
+    );
+  });
+
+  test('inserts after existing imports', () => {
+    const code = `import { foo } from 'bar';\nimport { baz } from 'qux';\n\n# Content`;
+    const config = { component: 'Code', moduleId: 'expressive-code' };
+    const result = injectExpressiveCodeComponent(code, config);
+    const lines = result.split('\n');
+    const codeImportIndex = lines.findIndex((line) =>
+      line.includes('import { Code }')
+    );
+    const lastImportIndex = lines.findIndex((line) =>
+      line.includes('import { baz }')
+    );
+    expect(codeImportIndex).toBeGreaterThan(lastImportIndex);
+  });
+
+  test('inserts at beginning when no imports exist', () => {
+    const code = `# Hello\n\nSome content`;
+    const config = { component: 'Code', moduleId: 'expressive-code' };
+    const result = injectExpressiveCodeComponent(code, config);
+    expect(result).toMatch(/^import { Code } from 'expressive-code';/);
+  });
+
+  test('does not inject if custom component name already imported', () => {
+    const code = `import { Code as MyCode } from 'somewhere';\n\n# Hello`;
+    const config = { component: 'MyCode', moduleId: 'expressive-code' };
+    const result = injectExpressiveCodeComponent(code, config);
+    expect(result).toBe(code);
+  });
+});

package/src/transforms/expressive-code.ts

@@ -0,0 +1,147 @@
+/**
+ * ExpressiveCode component injection and rewriting transforms
+ * @module transforms/expressive-code
+ */
+
+import { collectImportedNames, insertAfterImports } from '../utils/imports.js';
+import type { ExpressiveCodeConfig } from '../utils/config.js';
+
+/**
+ * Decodes HTML entities in a string.
+ */
+export function decodeHtmlEntities(value: string): string {
+  if (!value || !value.includes('&')) return value;
+  return value
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex: string) =>
+      String.fromCodePoint(Number.parseInt(hex, 16))
+    )
+    .replace(/&#([0-9]+);/g, (_, num: string) =>
+      String.fromCodePoint(Number.parseInt(num, 10))
+    )
+    .replace(/"/g, '"')
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+/**
+ * Result of rewriting ExpressiveCode blocks.
+ */
+export interface RewriteResult {
+  /** The transformed code */
+  code: string;
+  /** Whether any changes were made */
+  changed: boolean;
+}
+
+/**
+ * Rewrites <pre><code> blocks to ExpressiveCode components.
+ */
+export function rewriteExpressiveCodeBlocks(
+  code: string,
+  componentName: string
+): RewriteResult {
+  if (!code || typeof code !== 'string') {
+    return { code, changed: false };
+  }
+  // Pattern matches <pre> with optional attributes (class, tabindex, etc.)
+  // followed by <code> with optional language class
+  const pattern =
+    /<pre[^>]*><code(?: class="language-([^"]+)")?>([\s\S]*?)<\/code><\/pre>/g;
+  let changed = false;
+  const next = code.replace(pattern, (_match, lang: string | undefined, raw: string) => {
+    changed = true;
+    const decoded = decodeHtmlEntities(raw);
+    const props = [`code={${JSON.stringify(decoded)}}`];
+    if (lang) {
+      props.push(`lang="${lang}"`);
+    }
+    return `<${componentName} ${props.join(' ')} />`;
+  });
+  return { code: next, changed };
+}
+
+/**
+ * Rewrites code blocks inside Fragment set:html JSON strings.
+ *
+ * Handles: <_Fragment set:html={"<pre><code>...</code></pre>"} />
+ *
+ * When a code block inside a slot is transformed to ExpressiveCode component,
+ * the entire Fragment wrapper is replaced with the component directly.
+ */
+export function rewriteSetHtmlCodeBlocks(
+  code: string,
+  componentName: string
+): RewriteResult {
+  if (!code || typeof code !== 'string') {
+    return { code, changed: false };
+  }
+
+  const marker = '<_Fragment set:html={';
+  let result = code;
+  let changed = false;
+  let searchStart = 0;
+
+  while (true) {
+    const idx = result.indexOf(marker, searchStart);
+    if (idx === -1) break;
+
+    const start = idx + marker.length;
+    const end = result.indexOf('} />', start);
+    if (end === -1) break;
+
+    const literal = result.slice(start, end).trim();
+    let html: string;
+    try {
+      html = JSON.parse(literal) as string;
+    } catch {
+      searchStart = end;
+      continue;
+    }
+
+    // Apply ExpressiveCode rewrite to the HTML content
+    const rewritten = rewriteExpressiveCodeBlocks(html, componentName);
+    if (rewritten.changed) {
+      changed = true;
+      // If the rewritten content now has components, embed directly
+      // (replace the entire Fragment set:html wrapper)
+      if (/<[A-Z]/.test(rewritten.code)) {
+        // Replace Fragment set:html with direct content
+        result = result.slice(0, idx) + rewritten.code + result.slice(end + 4);
+        searchStart = idx + rewritten.code.length;
+      } else {
+        // Still pure HTML, re-encode
+        const encoded = JSON.stringify(rewritten.code);
+        result = result.slice(0, start) + encoded + result.slice(end);
+        searchStart = start + encoded.length + 4;
+      }
+    } else {
+      searchStart = end + 4;
+    }
+  }
+
+  return { code: result, changed };
+}
+
+/**
+ * Injects ExpressiveCode component import if needed.
+ */
+export function injectExpressiveCodeComponent(
+  code: string,
+  config: ExpressiveCodeConfig
+): string {
+  if (!code || typeof code !== 'string') {
+    return code;
+  }
+  const importName = config.component;
+  const imported = collectImportedNames(code);
+  if (imported.has(importName)) {
+    return code;
+  }
+  const importLine =
+    importName === 'Code'
+      ? `import { Code } from '${config.moduleId}';`
+      : `import { Code as ${importName} } from '${config.moduleId}';`;
+  return insertAfterImports(code, importLine);
+}

package/src/transforms/index.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for context-aware transform wrappers
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  transformExpressiveCode,
+  transformShikiHighlight,
+} from './index.js';
+import type { TransformContext } from '../types.js';
+
+/**
+ * Helper to create a minimal transform context
+ */
+function createContext(overrides: Partial<TransformContext> = {}): TransformContext {
+  return {
+    code: '',
+    source: '# Hello World',
+    filename: '/test/file.md',
+    frontmatter: {},
+    headings: [],
+    config: {
+      expressiveCode: null,
+      starlightComponents: false,
+      shiki: null,
+    },
+    ...overrides,
+  };
+}
+
+describe('transformExpressiveCode', () => {
+  test('returns context unchanged when expressiveCode is null', () => {
+    const ctx = createContext({
+      code: '<pre><code>const x = 1;</code></pre>',
+    });
+    const result = transformExpressiveCode(ctx);
+    expect(result.code).toBe('<pre><code>const x = 1;</code></pre>');
+  });
+
+  test('rewrites code blocks when expressiveCode is configured', () => {
+    const ctx = createContext({
+      code: '<pre><code>const x = 1;</code></pre>',
+      config: {
+        expressiveCode: { component: 'Code', moduleId: 'astro-expressive-code/components' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+    const result = transformExpressiveCode(ctx);
+    expect(result.code).toContain('<Code');
+    expect(result.code).toContain('code={');
+    expect(result.code).toContain("import { Code } from 'astro-expressive-code/components'");
+  });
+
+  test('rewrites code blocks with language', () => {
+    const ctx = createContext({
+      code: '<pre><code class="language-javascript">const x = 1;</code></pre>',
+      config: {
+        expressiveCode: { component: 'Code', moduleId: 'astro-expressive-code/components' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+    const result = transformExpressiveCode(ctx);
+    expect(result.code).toContain('<Code code={"const x = 1;"} lang="javascript" />');
+  });
+
+  test('uses custom component name', () => {
+    const ctx = createContext({
+      code: '<pre><code>const x = 1;</code></pre>',
+      config: {
+        expressiveCode: { component: 'MyCode', moduleId: 'my-code-module' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+    const result = transformExpressiveCode(ctx);
+    expect(result.code).toContain('<MyCode');
+    expect(result.code).toContain("import { Code as MyCode } from 'my-code-module'");
+  });
+});
+
+describe('transformShikiHighlight', () => {
+  test('returns context unchanged when shiki is null', async () => {
+    const ctx = createContext({
+      code: '<_Fragment set:html={"<pre><code>test</code></pre>"} />',
+    });
+    const result = await transformShikiHighlight(ctx);
+    expect(result.code).toBe('<_Fragment set:html={"<pre><code>test</code></pre>"} />');
+  });
+
+  test('applies shiki highlighting when enabled', async () => {
+    const mockHighlight = async (_code: string, _lang?: string): Promise<string> => {
+      return `<pre class="shiki"><code>${_code}</code></pre>`;
+    };
+    const ctx = createContext({
+      code: '<_Fragment set:html={"<pre><code>const x = 1;</code></pre>"} />',
+      config: {
+        expressiveCode: null,
+        starlightComponents: false,
+        shiki: mockHighlight,
+      },
+    });
+    const result = await transformShikiHighlight(ctx);
+    expect(result.code).toContain('shiki');
+  });
+});
+
+describe('context immutability', () => {
+  test('transforms return new context objects', () => {
+    const original = createContext({
+      code: '<pre><code>test</code></pre>',
+      config: {
+        expressiveCode: { component: 'Code', moduleId: 'astro-expressive-code/components' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+    const result = transformExpressiveCode(original);
+    expect(result).not.toBe(original);
+    expect(result.code).not.toBe(original.code);
+  });
+
+  test('transforms preserve other context properties', () => {
+    const ctx = createContext({
+      code: '<pre><code>test</code></pre>',
+      source: '```\ntest\n```',
+      filename: '/path/to/file.md',
+      frontmatter: { title: 'Test' },
+      headings: [{ text: 'Heading', depth: 1, slug: 'heading' }],
+      config: {
+        expressiveCode: { component: 'Code', moduleId: 'astro-expressive-code/components' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+    const result = transformExpressiveCode(ctx);
+    expect(result.source).toBe(ctx.source);
+    expect(result.filename).toBe(ctx.filename);
+    expect(result.frontmatter).toEqual(ctx.frontmatter);
+    expect(result.headings).toEqual(ctx.headings);
+  });
+});

package/src/transforms/index.ts

@@ -0,0 +1,100 @@
+/**
+ * Context-aware transform wrappers for pipeline composition
+ * @module transforms
+ */
+
+import {
+  rewriteExpressiveCodeBlocks,
+  rewriteSetHtmlCodeBlocks,
+  injectExpressiveCodeComponent,
+} from './expressive-code.js';
+import {
+  injectAstroComponents,
+  injectStarlightComponents,
+  injectComponentImportsFromRegistry,
+} from './inject-components.js';
+import { rewriteAstroSetHtml, highlightJsxCodeBlocks } from './shiki.js';
+import type { TransformContext } from '../types.js';
+
+/**
+ * Transform that rewrites <pre><code> blocks to ExpressiveCode components.
+ * Also handles code blocks inside set:html JSON strings (component slots).
+ * Only runs if expressiveCode is configured.
+ */
+export function transformExpressiveCode(ctx: TransformContext): TransformContext {
+  if (!ctx.config.expressiveCode || !ctx.code) {
+    return ctx;
+  }
+
+  const componentName = ctx.config.expressiveCode.component;
+
+  // First, rewrite code blocks inside set:html JSON strings (must run before
+  // the loose pattern, which would otherwise match <pre> inside JSON strings
+  // and corrupt the set:html wrapper)
+  let { code, changed } = rewriteSetHtmlCodeBlocks(ctx.code, componentName);
+
+  // Then, rewrite any remaining loose <pre><code> blocks
+  const looseResult = rewriteExpressiveCodeBlocks(code, componentName);
+  code = looseResult.code;
+  changed = changed || looseResult.changed;
+
+  if (changed) {
+    return {
+      ...ctx,
+      code: injectExpressiveCodeComponent(code, ctx.config.expressiveCode),
+    };
+  }
+  return { ...ctx, code };
+}
+
+/**
+ * Transform that applies Shiki syntax highlighting.
+ * Only runs if shiki highlighter is available.
+ *
+ * Processes code blocks in two passes:
+ * 1. rewriteAstroSetHtml: Handles code in <_Fragment set:html={...} /> patterns
+ * 2. highlightJsxCodeBlocks: Handles code in direct JSX <pre><code> elements
+ *    (when slot content with components bypasses set:html)
+ */
+export async function transformShikiHighlight(
+  ctx: TransformContext
+): Promise<TransformContext> {
+  if (!ctx.config.shiki || !ctx.code) {
+    return ctx;
+  }
+  // First pass: highlight code blocks in set:html fragments
+  let code = await rewriteAstroSetHtml(ctx.code, ctx.config.shiki);
+  // Second pass: highlight code blocks in direct JSX (mixed slots with components)
+  code = await highlightJsxCodeBlocks(code, ctx.config.shiki);
+  return { ...ctx, code };
+}
+
+/**
+ * Transform that injects component imports from the registry.
+ * Unified replacement for transformInjectAstroComponents and transformInjectStarlightComponents.
+ * Uses the registry from context to find all component modules and inject missing imports.
+ */
+export function transformInjectComponentsFromRegistry(ctx: TransformContext): TransformContext {
+  if (!ctx.code || !ctx.registry) {
+    return ctx;
+  }
+  return {
+    ...ctx,
+    code: injectComponentImportsFromRegistry(ctx.code, ctx.registry),
+  };
+}
+
+// Re-export from sub-modules
+export {
+  rewriteExpressiveCodeBlocks,
+  rewriteSetHtmlCodeBlocks,
+  injectExpressiveCodeComponent,
+} from './expressive-code.js';
+export {
+  injectAstroComponents,
+  injectStarlightComponents,
+  injectComponentImports,
+  injectComponentImportsFromRegistry,
+} from './inject-components.js';
+export { rewriteAstroSetHtml, highlightHtmlBlocks, highlightJsxCodeBlocks } from './shiki.js';
+export { blocksToJsx } from './blocks-to-jsx.js';