reallysimpledocs 1.0.0-beta.4 → 1.0.0-beta.5

package/src/runtime/lib/markdown-export.js

@@ -1,200 +1,163 @@
-import { gfmToMarkdown } from "mdast-util-gfm";
-import { toMarkdown } from "mdast-util-to-markdown";
-import remarkGfm from "remark-gfm";
-import remarkMdx from "remark-mdx";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-import { serializeComponent } from "./markdown-exporters/index.js";
-import { getMdxChildrenSource, trimCode } from "./mdx-source.js";
-
-const processor = unified().use(remarkParse).use(remarkGfm).use(remarkMdx);
-
-const customSerializersCache = new Map();
-
-export async function mdxToMarkdown(source, options = {}) {
-  const tree = processor.parse(source);
-  const state = {
-    constants: collectExportedStrings(tree),
-    customSerializers: await loadCustomSerializers(options.markdownSerializers),
-    source: String(source || ""),
-  };
-  const children = await transformBlocks(tree.children || [], state);
-  return `${stringify({ type: "root", children }).trim()}\n`;
-}
-
-async function loadCustomSerializers(entries = {}) {
-  const cacheKey = JSON.stringify(entries || {});
-  if (customSerializersCache.has(cacheKey)) return customSerializersCache.get(cacheKey);
-
-  const serializers = {};
-  for (const [name, moduleId] of Object.entries(entries || {})) {
-    if (!moduleId) continue;
-    const module = await import(/* @vite-ignore */ moduleId);
-    const serializer = module.default || module.serialize;
-    if (typeof serializer !== "function") {
-      throw new Error(`Markdown serializer for "${name}" must export a function as default or serialize.`);
-    }
-    serializers[name] = serializer;
+export function normalizeDocMarkdown(markdown, context = new Map()) {
+  return transformMarkdownTextSegments(markdown, (content) => {
+    return normalizeMdxComponents(stripMdxModuleSyntax(content), context);
+  })
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function stripMdxModuleSyntax(content) {
+  return String(content || "")
+    .replace(/^\s*import\s+[^;\n]+;?\s*$/gm, "")
+    .replace(/^\s*export\s+(?:const|let|var|function)\s+[\s\S]*?(?=\n(?:#|[A-Z][A-Za-z]*\(|<[A-Z]|\w|\s*$))/gm, "");
+}
+
+function transformMarkdownTextSegments(markdown, transform) {
+  return String(markdown || "")
+    .split(/(```[\s\S]*?```)/g)
+    .map((part) => (part.startsWith("```") ? part : transform(part)))
+    .join("");
+}
+
+const serializers = {
+  Code: serializeCode,
+  CodeGroup: serializeChildren,
+  Tabs: serializeChildren,
+  Tab: serializeChildren,
+  CardGrid: serializeChildren,
+  Preview: serializePreview,
+  Callout: serializeCallout,
+  Steps: serializeSteps,
+  Card: serializeCard,
+};
+
+export function normalizeMdxComponents(content, context = new Map()) {
+  let out = String(content || "");
+  const previewBlocks = [];
+
+  out = replacePairedComponent(out, "Preview", (attrs, children) => {
+    const token = `\u0000RSD_PREVIEW_${previewBlocks.length}\u0000`;
+    previewBlocks.push(serializers.Preview(attrs, children, context));
+    return token;
+  });
+
+  for (const name of ["CodeGroup", "Tabs", "Tab", "CardGrid", "Callout", "Steps", "Code"]) {
+    out = replacePairedComponent(out, name, (attrs, children) => serializers[name](attrs, children, context));
   }
 
-  customSerializersCache.set(cacheKey, serializers);
-  return serializers;
+  out = out.replace(/<Code\b([^>]*)\/>/g, (_, attrs) => serializeCode(attrs, getCodeAttr(attrs, context), context));
+  out = out.replace(/<Card\b([^>]*)\/>/g, (_, attrs) => serializeCard(attrs));
+  previewBlocks.forEach((block, index) => {
+    out = out.replaceAll(`\u0000RSD_PREVIEW_${index}\u0000`, block);
+  });
+
+  return out;
 }
 
-async function transformBlocks(nodes, state) {
-  const blocks = [];
-  for (const node of nodes) {
-    blocks.push(...(await transformBlock(node, state)));
-  }
-  return blocks.filter(Boolean);
+function replacePairedComponent(content, name, serialize) {
+  return content.replace(new RegExp(`<${name}\\b([^>]*)>([\\s\\S]*?)<\\/${name}>`, "g"), (_, attrs, children) =>
+    serialize(attrs, children),
+  );
 }
 
-async function transformBlock(node, state) {
-  if (!node) return [];
+function serializeChildren(_attrs, children, context = new Map()) {
+  return `\n\n${normalizeMdxComponents(children, context).trim()}\n\n`;
+}
 
-  if (node.type === "mdxjsEsm") return [];
+function serializePreview(attrs, children, context = new Map()) {
+  const lang = getStringAttr(attrs, "lang") || "mdx";
+  const code = getExpressionAttr(attrs, "code");
+  const source = stripCommonIndent(code && context.has(code) ? context.get(code) : children).trim();
+  return `\n\n${fencedCode(lang, source)}\n\n`;
+}
 
-  if (isMdxElement(node)) {
-    return await transformComponent(node, state);
-  }
+function serializeCallout(attrs, children, context = new Map()) {
+  const title = getStringAttr(attrs, "title") || calloutTitle(getStringAttr(attrs, "type"));
+  const body = normalizeMdxComponents(children, context)
+    .trim()
+    .split("\n")
+    .map((line) => `> ${line}`)
+    .join("\n");
+  return `\n\n> **${title}**\n${body ? `${body}\n` : ""}\n`;
+}
 
-  if (node.type === "paragraph") {
-    const children = significantChildren(node.children || []);
-    if (children.length === 1 && isMdxElement(children[0])) {
-      return await transformComponent(children[0], state);
-    }
-  }
+function serializeSteps(_attrs, children, context = new Map()) {
+  let index = 0;
+  const steps = children.replace(/<Step\b([^>]*)>([\s\S]*?)<\/Step>/g, (_step, attrs, body) => {
+    index += 1;
+    const title = getStringAttr(attrs, "title");
+    const text = normalizeMdxComponents(body, context).trim();
+    return `${index}. ${title ? `**${title}**` : ""}${text ? `\n\n${indentMarkdown(text, "   ")}` : ""}`;
+  });
+  return `\n\n${steps}\n\n`;
+}
 
-  const clone = { ...node };
-  if (Array.isArray(clone.children)) {
-    if (isBlockContainer(clone.type)) {
-      clone.children = await transformBlocks(clone.children, state);
-    } else {
-      clone.children = await transformInline(clone.children, state);
-    }
-  }
-  return [clone];
-}
-
-async function transformComponent(node, state) {
-  return (
-    (await serializeComponent(
-      node,
-      {
-        transformBlocks: (nodes) => transformBlocks(nodes, state),
-        getAttr: (entry, name) => getAttr(entry, name, state.constants),
-        getCodeValue: (entry) => getCodeValue(entry, state.constants),
-        getChildrenSource: (entry) => getMdxChildrenSource(entry, state.source),
-        isNamedElement,
-        significantChildren,
-      },
-      state.customSerializers,
-    )) || (await transformBlocks(node.children || [], state))
-  );
+function serializeCode(attrs, children, context = new Map()) {
+  const lang = getStringAttr(attrs, "lang") || "text";
+  const title = getStringAttr(attrs, "title");
+  const label = title ? ` ${title}` : "";
+  const code = unwrapMdxString(children, context).trim();
+  return `\n\n${fencedCode(`${lang}${label}`, code)}\n\n`;
 }
 
-async function transformInline(nodes, state) {
-  const inline = [];
-  for (const node of nodes) {
-    if (isMdxElement(node)) {
-      const text = stringify({ type: "root", children: await transformComponent(node, state) }).trim();
-      if (text) inline.push({ type: "text", value: text });
-      continue;
-    }
-    if (node.type === "mdxTextExpression" || node.type === "mdxFlowExpression") {
-      const value = expressionValue(node, state.constants);
-      if (value) inline.push({ type: "text", value });
-      continue;
-    }
-    const clone = { ...node };
-    if (Array.isArray(clone.children)) clone.children = await transformInline(clone.children, state);
-    inline.push(clone);
-  }
-  return inline;
+function serializeCard(attrs) {
+  const title = getStringAttr(attrs, "title") || "Card";
+  const description = getStringAttr(attrs, "description");
+  const href = getStringAttr(attrs, "href");
+  const label = description ? `**${title}**: ${description}` : `**${title}**`;
+  return href ? `\n\n- [${label}](${href})\n` : `\n\n- ${label}\n`;
 }
 
-function getCodeValue(node, constants) {
-  const parts = (node.children || []).map((child) => {
-    if (child.type === "text") return child.value || "";
-    if (child.type === "mdxFlowExpression" || child.type === "mdxTextExpression") {
-      return expressionValue(child, constants);
-    }
-    return "";
-  });
-  return trimCode(parts.join("") || String(getAttr(node, "code", constants) || ""));
-}
-
-function getAttr(node, name, constants) {
-  const attr = (node.attributes || []).find((entry) => entry.type === "mdxJsxAttribute" && entry.name === name);
-  if (!attr) return "";
-  if (attr.value == null) return "true";
-  if (typeof attr.value === "string") return attr.value;
-  return expressionValue(attr.value, constants);
-}
-
-function collectExportedStrings(tree) {
-  const constants = new Map();
-  for (const node of tree.children || []) {
-    if (node.type !== "mdxjsEsm") continue;
-    for (const statement of node.data?.estree?.body || []) {
-      if (statement.type !== "ExportNamedDeclaration") continue;
-      if (statement.declaration?.type !== "VariableDeclaration") continue;
-      for (const declaration of statement.declaration.declarations || []) {
-        if (declaration.id?.type !== "Identifier") continue;
-        const value = staticValue(declaration.init, constants);
-        if (value) constants.set(declaration.id.name, value);
-      }
-    }
-  }
-  return constants;
+function getStringAttr(attrs, name) {
+  return String(attrs || "").match(new RegExp(`${name}=["']([^"']*)["']`))?.[1] || "";
 }
 
-function expressionValue(node, constants) {
-  const expression = node.data?.estree?.body?.[0]?.expression || node.data?.estree?.body?.[0];
-  return staticValue(expression, constants) || "";
+function getExpressionAttr(attrs, name) {
+  return String(attrs || "").match(new RegExp(`${name}=\\{([A-Za-z_$][\\w$]*)\\}`))?.[1] || "";
 }
 
-function staticValue(node, constants) {
-  if (!node) return "";
-  if (node.type === "Literal") return node.value ?? "";
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw ?? "").join("");
-  }
-  if (node.type === "Identifier") return constants.get(node.name) || "";
-  if (node.type === "ObjectExpression") {
-    return Object.fromEntries(
-      node.properties
-        .filter((property) => property.type === "Property")
-        .map((property) => [property.key.name || property.key.value, staticValue(property.value, constants)]),
-    );
-  }
-  if (node.type === "ArrayExpression") {
-    return node.elements.map((element) => staticValue(element, constants));
-  }
-  return "";
+function getCodeAttr(attrs, context = new Map()) {
+  const direct = String(attrs || "").match(/\bcode=\{`([\s\S]*?)`\}/)?.[1] || "";
+  if (direct) return direct.replace(/\\n/g, "\n").replace(/\\`/g, "`");
+  const ref = getExpressionAttr(attrs, "code");
+  return ref && context.has(ref) ? context.get(ref) : "";
 }
 
-function stringify(tree) {
-  return toMarkdown(tree, {
-    bullet: "-",
-    fences: true,
-    rule: "-",
-    extensions: [gfmToMarkdown()],
-  });
+function unwrapMdxString(value, context = new Map()) {
+  const text = String(value || "").trim();
+  const ref = text.match(/^\{([A-Za-z_$][\w$]*)\}$/)?.[1];
+  if (ref && context.has(ref)) return context.get(ref);
+  const template = text.match(/^\{`([\s\S]*)`\}$/);
+  if (template) return template[1].replace(/\\n/g, "\n").replace(/\\`/g, "`");
+  return text.replace(/^\{["']([\s\S]*)["']\}$/, "$1");
+}
+
+function calloutTitle(type) {
+  if (type === "warning") return "Warning";
+  if (type === "destructive") return "Danger";
+  return "Note";
 }
 
-function isMdxElement(node) {
-  return node?.type === "mdxJsxFlowElement" || node?.type === "mdxJsxTextElement";
+function indentMarkdown(markdown, prefix) {
+  return String(markdown || "")
+    .split("\n")
+    .map((line) => `${prefix}${line}`)
+    .join("\n");
 }
 
-function isNamedElement(node, name) {
-  return isMdxElement(node) && node.name === name;
+function fencedCode(info, code) {
+  const fence = longestBacktickRun(code) >= 3 ? "`".repeat(longestBacktickRun(code) + 1) : "```";
+  return `${fence}${info}\n${code}\n${fence}`;
 }
 
-function significantChildren(children) {
-  return children.filter((child) => child.type !== "text" || child.value.trim());
+function longestBacktickRun(value) {
+  return Math.max(0, ...String(value || "").matchAll(/`+/g).map((match) => match[0].length));
 }
 
-function isBlockContainer(type) {
-  return type === "root" || type === "blockquote" || type === "list" || type === "listItem";
+function stripCommonIndent(value) {
+  const lines = String(value || "").replace(/^\n+|\n+$/g, "").split("\n");
+  const indents = lines.filter((line) => line.trim()).map((line) => line.match(/^[ \t]*/)[0].length);
+  const indent = indents.length ? Math.min(...indents) : 0;
+  return indent ? lines.map((line) => line.slice(Math.min(indent, line.match(/^[ \t]*/)[0].length))).join("\n") : lines.join("\n");
 }

package/src/runtime/pages/doc.astro

@@ -1,6 +1,5 @@
 ---
 import config from "virtual:reallysimpledocs/config";
-import UserMdxComponents from "virtual:reallysimpledocs/mdx-components";
 import { getMdxPage } from "virtual:reallysimpledocs/mdx-pages";
 import * as RsdComponents from "../../components/index.js";
 import DocsLayout from "../components/DocsLayout.astro";
@@ -19,9 +18,8 @@ const isMdx = page.extension === ".mdx";
 const mdxModule = isMdx ? await getMdxPage(page.slug) : null;
 const MdxContent = mdxModule?.Content || mdxModule?.default;
 const doc = isMdx ? { page, headings: getDocHeadings(config, page), html: "" } : await renderDoc(config, page);
-const mdxComponents = { ...RsdComponents, ...UserMdxComponents };
 ---
 
 <DocsLayout page={page} headings={doc.headings}>
-  {MdxContent ? <MdxContent components={mdxComponents} /> : <Fragment set:html={doc.html} />}
+  {MdxContent ? <MdxContent components={RsdComponents} /> : <Fragment set:html={doc.html} />}
 </DocsLayout>

package/src/runtime/pages/llms-full.txt.ts

@@ -2,12 +2,12 @@ import config from "virtual:reallysimpledocs/config";
 import { getLlmDocs } from "../lib/docs.js";
 import { getSite } from "../lib/site.js";
 
-export async function GET({ site }) {
+export function GET({ site }) {
   const siteData = getSite(config);
   const siteUrl = site?.toString().replace(/\/$/, "") || siteData.url || "";
   const lines = [];
 
-  (await getLlmDocs(config)).forEach((doc) => {
+  getLlmDocs(config).forEach((doc) => {
     lines.push(`# ${doc.title}`, `Source: ${siteUrl}${doc.path}`, "");
     lines.push(doc.content, "", "---", "");
   });

package/src/runtime/pages/llms.txt.ts

@@ -2,9 +2,9 @@ import config from "virtual:reallysimpledocs/config";
 import { flattenMenuSlugs, getLlmDocs, getManifest } from "../lib/docs.js";
 import { getSite } from "../lib/site.js";
 
-export async function GET({ site }) {
+export function GET({ site }) {
   const manifest = getManifest(config);
-  const docs = await getLlmDocs(config);
+  const docs = getLlmDocs(config);
   const bySlug = new Map(docs.map((doc) => [doc.slug, doc]));
   const siteData = getSite(config);
   const siteUrl = site?.toString().replace(/\/$/, "") || siteData.url || "";

package/src/runtime/pages/markdown.ts

@@ -8,8 +8,8 @@ export function getStaticPaths() {
   }));
 }
 
-export async function GET({ props }) {
-  return new Response(await getMarkdownExport(config, props.page), {
+export function GET({ props }) {
+  return new Response(getMarkdownExport(config, props.page), {
     headers: {
       "content-type": "text/markdown; charset=utf-8",
     },

package/src/runtime/pages/search-index.ts

@@ -2,12 +2,14 @@ import lunr from "lunr";
 import config from "virtual:reallysimpledocs/config";
 import { getSearchDocs } from "../lib/docs.js";
 
-export async function GET() {
-  const documents = await getSearchDocs(config);
+export function GET() {
+  const documents = getSearchDocs(config);
   const index = lunr(function () {
     this.ref("slug");
     this.field("title", { boost: 10 });
+    this.field("breadcrumb", { boost: 8 });
     this.field("body");
+    this.field("code", { boost: 0.2 });
     this.metadataWhitelist = ["position"];
 
     documents.forEach((doc) => this.add(doc));
@@ -16,7 +18,14 @@ export async function GET() {
   return new Response(
     JSON.stringify({
       index,
-      documents: documents.map(({ slug, title, path, body }) => ({ slug, title, path, body })),
+      documents: documents.map(({ slug, title, breadcrumb, path, body, code }) => ({
+        slug,
+        title,
+        breadcrumb,
+        path,
+        body,
+        code,
+      })),
     }),
     {
       headers: {

package/CHANGELOG.md

@@ -1,35 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
-
-## [1.0.0-beta.4] - 2026-06-16
-
-### Added
-
-- Added MDX documentation components for callouts, code blocks, code groups, previews, tabs, steps, and cards.
-- Added automatic MDX component availability in docs pages, so common ReallySimpleDocs components do not need page-level imports.
-- Added custom `mdxComponents` registration for project-specific MDX components.
-- Added custom `markdownSerializers` registration so project-specific MDX components can control Markdown, search, and LLM export output.
-- Added Markdown export serializers for ReallySimpleDocs components so generated Markdown, search content, and `llms-full.txt` avoid raw MDX component noise.
-- Added customizable sidebar header, sidebar footer, and content header component overrides.
-- Added breadcrumb rendering from the docs navigation tree.
-- Added Lunr-powered command search with result previews and highlighted matches.
-- Added Basecoat style selection through the ReallySimpleDocs integration config.
-
-### Changed
-
-- Ported ReallySimpleDocs to an Astro integration with generated docs routes, assets, Markdown exports, search index, and Basecoat styling.
-- Updated docs content to use Markdown by default and MDX only for richer component examples.
-- Updated code examples to use inline component children instead of passing source code as props.
-- Changed empty table-of-contents behavior so the right panel is hidden instead of rendering an empty “On this page” section.
-- Changed breadcrumbs to render in the sticky content header for nested pages.
-- Updated the docs overview and component pages to explain component usage, Markdown output, and Basecoat interoperability.
-
-### Fixed
-
-- Fixed Shiki code block colors across light and dark mode.
-- Fixed copy-code button layout for regular code blocks and tabbed code blocks.
-- Fixed callout rendering in Markdown and MDX pages.
-- Fixed sidebar and header markup to follow Basecoat component patterns.

package/src/css/overrides.css

@@ -1 +0,0 @@
-/* Custom CSS overrides (loaded last). */

package/src/css/sources.css

@@ -1 +0,0 @@
-@source "../runtime/**/*.{astro,js,ts}";

package/src/runtime/lib/markdown-exporters/index.js

@@ -1,144 +0,0 @@
-const serializers = {
-  Callout: renderCallout,
-  Code: renderCode,
-  CodeGroup: renderCodeGroup,
-  Preview: renderPreview,
-  Steps: renderSteps,
-  Tabs: renderChildren,
-  Card: renderCard,
-  CardGrid: renderCardGrid,
-};
-
-export async function serializeComponent(node, context, customSerializers = {}) {
-  if (customSerializers[node.name]) return await customSerializers[node.name](node, context);
-  return serializers[node.name]?.(node, context) || null;
-}
-
-async function renderChildren(node, context) {
-  return await context.transformBlocks(node.children || []);
-}
-
-async function renderCallout(node, context) {
-  const title = context.getAttr(node, "title");
-  const action = context.getAttr(node, "action");
-  const children = await context.transformBlocks(node.children || []);
-  const quoteChildren = [];
-  if (title) quoteChildren.push(strongParagraph(title));
-  quoteChildren.push(...children);
-  if (action?.label) {
-    quoteChildren.push({
-      type: "paragraph",
-      children: action.href
-        ? [{ type: "link", url: action.href, children: [{ type: "text", value: action.label }] }]
-        : [{ type: "strong", children: [{ type: "text", value: action.label }] }],
-    });
-  }
-  return [{ type: "blockquote", children: quoteChildren }];
-}
-
-function renderCode(node, context) {
-  const title = context.getAttr(node, "title") || context.getAttr(node, "slot");
-  const lang = context.getAttr(node, "lang") || "text";
-  const value = context.getCodeValue(node);
-  const blocks = [];
-  if (title) blocks.push(strongParagraph(title));
-  blocks.push({ type: "code", lang, value });
-  return blocks;
-}
-
-function renderCodeGroup(node, context) {
-  const codeNodes = collectCodeChildren(node, context);
-  if (!codeNodes.length) return renderChildren(node, context);
-  return codeNodes.flatMap((child, index) => {
-    const blocks = renderCode(child, context);
-    return index === 0 ? blocks : [{ type: "thematicBreak" }, ...blocks];
-  });
-}
-
-async function renderPreview(node, context) {
-  const value = context.getAttr(node, "code") || context.getChildrenSource(node);
-  if (value) {
-    return [{ type: "code", lang: context.getAttr(node, "lang") || "mdx", value }];
-  }
-  return await renderChildren(node, context);
-}
-
-async function renderSteps(node, context) {
-  const steps = (node.children || []).filter((child) => context.isNamedElement(child, "Step"));
-  if (!steps.length) return await renderChildren(node, context);
-  const children = [];
-  for (const step of steps) {
-    children.push({
-      type: "listItem",
-      spread: true,
-      children: await stepToBlocks(step, context),
-    });
-  }
-  return [
-    {
-      type: "list",
-      ordered: true,
-      spread: true,
-      children,
-    },
-  ];
-}
-
-function renderCard(node, context) {
-  return [cardList([node], context)];
-}
-
-function renderCardGrid(node, context) {
-  return [cardList((node.children || []).filter((child) => context.isNamedElement(child, "Card")), context)];
-}
-
-async function stepToBlocks(node, context) {
-  const title = context.getAttr(node, "title");
-  const children = await context.transformBlocks(node.children || []);
-  if (!title) return children;
-  return [strongParagraph(title), ...children];
-}
-
-function cardList(cards, context) {
-  return {
-    type: "list",
-    ordered: false,
-    spread: true,
-    children: cards.map((card) => ({
-      type: "listItem",
-      spread: false,
-      children: [cardParagraph(card, context)],
-    })),
-  };
-}
-
-function cardParagraph(node, context) {
-  const title = context.getAttr(node, "title") || "Card";
-  const description = context.getAttr(node, "description");
-  const href = context.getAttr(node, "href");
-  const titleNode =
-    href && href !== "#"
-      ? { type: "link", url: href, children: [{ type: "text", value: title }] }
-      : { type: "strong", children: [{ type: "text", value: title }] };
-  return {
-    type: "paragraph",
-    children: description ? [titleNode, { type: "text", value: `: ${description}` }] : [titleNode],
-  };
-}
-
-function collectCodeChildren(node, context) {
-  return (node.children || []).flatMap((child) => {
-    if (context.isNamedElement(child, "Code")) return [child];
-    if (child.type === "paragraph") {
-      return context.significantChildren(child.children || []).filter((entry) => context.isNamedElement(entry, "Code"));
-    }
-    return [];
-  });
-}
-
-function strongParagraph(value) {
-  return {
-    type: "paragraph",
-    children: [{ type: "strong", children: [{ type: "text", value }] }],
-  };
-}

package/src/runtime/lib/mdx-source.js

@@ -1,19 +0,0 @@
-export function getMdxChildrenSource(node, source) {
-  const children = node?.children || [];
-  const first = children[0];
-  const last = children.at(-1);
-  const start = first?.position?.start?.offset;
-  const end = last?.position?.end?.offset;
-  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return "";
-  return trimCode(String(source || "").slice(start, end));
-}
-
-export function trimCode(value) {
-  const lines = String(value || "").replace(/\r\n/g, "\n").split("\n");
-  while (lines.length && !lines[0].trim()) lines.shift();
-  while (lines.length && !lines.at(-1).trim()) lines.pop();
-  const indent = lines
-    .filter((line) => line.trim())
-    .reduce((min, line) => Math.min(min, line.match(/^\s*/)[0].length), Infinity);
-  return lines.map((line) => line.slice(Number.isFinite(indent) ? indent : 0)).join("\n");
-}