@waveso/docs 0.1.0

package/dist/plugins/rehype-capture-toc.js

@@ -0,0 +1,69 @@
+import { SKIP, visit } from "unist-util-visit";
+import { toString } from "hast-util-to-string";
+//#region src/plugins/rehype-capture-toc.ts
+/** `h2`–`h6`. `h1` is the page title and never appears in a TOC. */
+const HEADING = /^h([2-6])$/;
+/**
+* Drop the permalink anchor `rehype-autolink-headings` appends.
+*
+* This plugin is ordered before that one, so in practice there is nothing to
+* drop — but the check costs nothing and the alternative, if the order ever
+* changes, is every TOC entry silently gaining a trailing `#`.
+*/
+function isPermalink(child) {
+	if (child.type !== "element" || child.tagName !== "a") return false;
+	const className = child.properties.className;
+	const ariaHidden = child.properties.ariaHidden;
+	return ariaHidden === true || ariaHidden === "true" || Array.isArray(className) && className.includes("heading-anchor");
+}
+/**
+* The GFM footnote block `mdast-util-to-hast` appends.
+*
+* It carries a generated `<h2 id="footnote-label">Footnotes</h2>` that is
+* machinery rather than a section of the page — and is visually hidden, so a
+* TOC entry for it points the reader at nothing they can see. `search-index.ts`
+* skips the same subtree; the two must agree about which sections exist.
+*/
+function isFootnotes(node) {
+	return node.properties.dataFootnotes !== void 0;
+}
+function headingText(node) {
+	return node.children.filter((child) => !isPermalink(child)).map((child) => toString(child)).join("").trim();
+}
+/**
+* rehype plugin. Must run after `rehype-slug`; ordering is enforced by the
+* renderer rather than checked here, because a heading legitimately may have
+* been given an id by hand.
+*/
+const rehypeCaptureToc = () => {
+	return (tree, file) => {
+		const toc = [];
+		/** Open ancestors, outermost first. */
+		const stack = [];
+		visit(tree, "element", (node) => {
+			if (isFootnotes(node)) return SKIP;
+			const level = HEADING.exec(node.tagName)?.[1];
+			if (level === void 0) return;
+			const id = node.properties.id;
+			if (typeof id !== "string" || id === "") return;
+			const entry = {
+				id,
+				text: headingText(node),
+				depth: Number(level),
+				children: []
+			};
+			while (stack.length > 0) {
+				const top = stack[stack.length - 1];
+				if (top !== void 0 && top.depth < entry.depth) break;
+				stack.pop();
+			}
+			const parent = stack[stack.length - 1];
+			if (parent === void 0) toc.push(entry);
+			else parent.children.push(entry);
+			stack.push(entry);
+		});
+		file.data.toc = toc;
+	};
+};
+//#endregion
+export { rehypeCaptureToc };

package/dist/plugins/remark-doc-links.d.ts

@@ -0,0 +1,63 @@
+import { DocLinkContext, LinkResolver } from "../types.js";
+import { Plugin } from "unified";
+import { Root } from "mdast";
+//#region src/plugins/remark-doc-links.d.ts
+/**
+ * Where a link was found and what it resolved to.
+ *
+ * `href` is `undefined` when resolution failed — an unknown resolver result,
+ * or a `../` chain that climbs out of the content root. That is a distinct
+ * condition from "resolved but the page does not exist", and the caller
+ * reports them differently.
+ */
+interface DocLinkRef {
+  /** The href exactly as authored, e.g. `'./api/auth.md'`. */
+  raw: string;
+  /** Resolved route including `?query` and `#anchor`, or `undefined`. */
+  href: string | undefined;
+  /** 1-based line in the source markdown, when the parser recorded one. */
+  line?: number;
+}
+declare module 'vfile' {
+  interface DataMap {
+    /** Set by the caller before running the processor. */
+    docLinkContext: DocLinkContext;
+    /** Appended to by {@link remarkDocLinks}. */
+    docLinks: DocLinkRef[];
+  }
+}
+interface RemarkDocLinksOptions {
+  /** URL prefix the docs are mounted at, e.g. `'/docs'`. */
+  basePath: string;
+  /** Overrides the built-in resolution entirely, for every relative link. */
+  resolve?: LinkResolver;
+}
+/**
+ * Fold `.` and `..` against a starting directory.
+ *
+ * Hand-rolled rather than `path.resolve` because these are URL paths, not
+ * filesystem paths: they must use `/` on Windows and must not pick up the
+ * process working directory. Returns `undefined` when the chain climbs above
+ * the content root, which is always an authoring error worth surfacing.
+ *
+ * EXPORTED as part of the wrap-don't-replace surface. Getting `../` right is
+ * the fiddly half of writing a {@link LinkResolver}, and a host that reuses
+ * this cannot disagree with the built-in resolver about where a link points.
+ * It is also what `render.ts` folds image sources with, so links and images
+ * are contained by one implementation rather than two.
+ */
+declare function foldSegments(from: readonly string[], path: string): string[] | undefined;
+/**
+ * The built-in {@link LinkResolver}: markdown file path in, route out.
+ *
+ * Exported for reuse by hosts that want to wrap rather than replace it.
+ */
+declare function resolveMarkdownLink(href: string, fromDir: readonly string[], basePath: string): string | undefined;
+/**
+ * remark plugin. Requires `file.data.docLinkContext` to be set; without it the
+ * containing document is unknown and every relative link would resolve against
+ * the content root, which is worse than leaving them alone.
+ */
+declare const remarkDocLinks: Plugin<[RemarkDocLinksOptions], Root>;
+//#endregion
+export { type DocLinkContext, DocLinkRef, RemarkDocLinksOptions, foldSegments, remarkDocLinks, resolveMarkdownLink };

package/dist/plugins/remark-doc-links.js

@@ -0,0 +1,122 @@
+import { visit } from "unist-util-visit";
+//#region src/plugins/remark-doc-links.ts
+/** `scheme:` — matches `https:`, `mailto:`, `tel:`, `data:`. */
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/** Splits `path?query#hash`; every group is optional. */
+const HREF_PARTS = /^([^?#]*)(\?[^#]*)?(#.*)?$/;
+const MARKDOWN_EXTENSION = /\.mdx?$/i;
+/** A dot-extension on the final segment, e.g. `.png` in `img/logo.png`. */
+const FILE_EXTENSION = /\.[^./]+$/;
+/**
+* Does this href point at another page in the same docs tree?
+*
+* Absolute paths are already routes, in-page anchors are already correct, and
+* anything with a scheme belongs to someone else. A path-less href — `?tab=json`
+* — addresses the current page and is left alone for the same reason `#anchor`
+* is: there is nothing to resolve, and resolving it to `undefined` would fail
+* the build with advice the author cannot act on.
+*/
+function isRelativeLink(href) {
+	return href !== "" && !href.startsWith("#") && !href.startsWith("?") && !href.startsWith("/") && !HAS_SCHEME.test(href);
+}
+/**
+* Fold `.` and `..` against a starting directory.
+*
+* Hand-rolled rather than `path.resolve` because these are URL paths, not
+* filesystem paths: they must use `/` on Windows and must not pick up the
+* process working directory. Returns `undefined` when the chain climbs above
+* the content root, which is always an authoring error worth surfacing.
+*
+* EXPORTED as part of the wrap-don't-replace surface. Getting `../` right is
+* the fiddly half of writing a {@link LinkResolver}, and a host that reuses
+* this cannot disagree with the built-in resolver about where a link points.
+* It is also what `render.ts` folds image sources with, so links and images
+* are contained by one implementation rather than two.
+*/
+function foldSegments(from, path) {
+	const out = [...from];
+	for (const part of path.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			if (out.length === 0) return;
+			out.pop();
+			continue;
+		}
+		out.push(part);
+	}
+	return out;
+}
+/** Join route segments onto the base path, e.g. `('/docs', ['api'])`. */
+function toRoute(basePath, segments) {
+	const base = basePath.replace(/\/+$/, "");
+	const path = segments.join("/");
+	if (path === "") return base === "" ? "/" : base;
+	return `${base}/${path}`;
+}
+/**
+* The built-in {@link LinkResolver}: markdown file path in, route out.
+*
+* Exported for reuse by hosts that want to wrap rather than replace it.
+*/
+function resolveMarkdownLink(href, fromDir, basePath) {
+	const parts = HREF_PARTS.exec(href);
+	const path = parts?.[1] ?? "";
+	const query = parts?.[2] ?? "";
+	const hash = parts?.[3] ?? "";
+	if (path === "") return;
+	const segments = foldSegments(fromDir, path);
+	if (segments === void 0) return;
+	const last = segments.at(-1);
+	if (last !== void 0) {
+		const stripped = last.replace(MARKDOWN_EXTENSION, "");
+		if (stripped === "index") segments.pop();
+		else segments[segments.length - 1] = stripped;
+	}
+	return `${toRoute(basePath, segments)}${query}${hash}`;
+}
+/**
+* Is this relative href pointing at an asset rather than a page?
+*
+* A link to `./diagram.svg` or `./schema.sql` is a download, not a route, and
+* rewriting it would break it. Markdown extensions are pages; any other
+* extension on the final segment is an asset; no extension is a page.
+* The false positive is a page literally named `v2.0`, which is rare enough
+* to accept and is fixed by writing `v2.0.md`.
+*/
+function isAssetLink(href) {
+	const last = (HREF_PARTS.exec(href)?.[1] ?? "").split("/").at(-1) ?? "";
+	return FILE_EXTENSION.test(last) && !MARKDOWN_EXTENSION.test(last);
+}
+/**
+* remark plugin. Requires `file.data.docLinkContext` to be set; without it the
+* containing document is unknown and every relative link would resolve against
+* the content root, which is worse than leaving them alone.
+*/
+const remarkDocLinks = (options) => {
+	const { basePath, resolve } = options;
+	return (tree, file) => {
+		const context = file.data.docLinkContext;
+		if (context === void 0) throw new Error(`@waveso/docs: remarkDocLinks ran without file.data.docLinkContext${file.path === void 0 ? "" : ` (file: ${file.path})`}. Set it before running the processor.`);
+		const refs = file.data.docLinks ?? [];
+		file.data.docLinks = refs;
+		visit(tree, ["link", "definition"], (node) => {
+			if (node.type !== "link" && node.type !== "definition") return;
+			const raw = node.url;
+			if (!isRelativeLink(raw)) return;
+			if (resolve === void 0 && isAssetLink(raw)) return;
+			const href = resolve ? resolve(raw, context) : resolveMarkdownLink(raw, context.dirSegments, basePath);
+			const line = node.position?.start.line;
+			refs.push(line === void 0 ? {
+				raw,
+				href
+			} : {
+				raw,
+				href,
+				line
+			});
+			if (href !== void 0) node.url = href;
+		});
+	};
+};
+//#endregion
+export { foldSegments, remarkDocLinks, resolveMarkdownLink };

package/dist/plugins/remark-unwrap-images.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "unified";
+import { Root } from "mdast";
+//#region src/plugins/remark-unwrap-images.d.ts
+/**
+ * remark plugin. Only unwraps paragraphs whose sole meaningful child is an
+ * image — a paragraph with a caption beside the image is prose, and prose
+ * belongs in a paragraph.
+ */
+declare const remarkUnwrapImages: Plugin<[], Root>;
+//#endregion
+export { remarkUnwrapImages };

package/dist/plugins/remark-unwrap-images.js

@@ -0,0 +1,25 @@
+import { SKIP, visit } from "unist-util-visit";
+//#region src/plugins/remark-unwrap-images.ts
+/** Whitespace-only text is what separates `![a](a.png)\n![b](b.png)`. */
+function isIgnorable(node) {
+	return node.type === "text" && node.value.trim() === "";
+}
+/**
+* remark plugin. Only unwraps paragraphs whose sole meaningful child is an
+* image — a paragraph with a caption beside the image is prose, and prose
+* belongs in a paragraph.
+*/
+const remarkUnwrapImages = () => {
+	return (tree) => {
+		visit(tree, "paragraph", (node, index, parent) => {
+			if (parent === void 0 || index === void 0) return;
+			const meaningful = node.children.filter((child) => !isIgnorable(child));
+			const only = meaningful[0];
+			if (meaningful.length !== 1 || only === void 0 || only.type !== "image" && only.type !== "imageReference") return;
+			parent.children[index] = only;
+			return [SKIP, index + 1];
+		});
+	};
+};
+//#endregion
+export { remarkUnwrapImages };

package/dist/plugins/remark-youtube.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "unified";
+import { Root } from "mdast";
+//#region src/plugins/remark-youtube.d.ts
+/**
+ * Extract a video id from a YouTube watch/short/embed URL.
+ *
+ * Returns `undefined` for anything else, including YouTube URLs that are not a
+ * single video (channels, playlists) — those stay ordinary links.
+ */
+declare function parseYouTubeId(href: string): string | undefined;
+/**
+ * remark plugin. Replaces the whole PARAGRAPH, not the link inside it — which
+ * is the point: leaving the paragraph is what nested a block element in
+ * phrasing content.
+ *
+ * `data.hName` / `data.hProperties` is how `mdast-util-to-hast` is told to
+ * serialise a node as something other than its default, so the output is a
+ * plain hast element and the React layer maps it like any other.
+ */
+declare const remarkYouTube: Plugin<[], Root>;
+//#endregion
+export { parseYouTubeId, remarkYouTube };

package/dist/plugins/remark-youtube.js

@@ -0,0 +1,84 @@
+import { SKIP, visit } from "unist-util-visit";
+//#region src/plugins/remark-youtube.ts
+/** YouTube ids are exactly eleven URL-safe characters. */
+const VIDEO_ID = /^[A-Za-z0-9_-]{11}$/;
+/** `https://` or `http://`, for comparing a label against its own href. */
+const HTTP_SCHEME = /^https?:\/\//i;
+/**
+* Extract a video id from a YouTube watch/short/embed URL.
+*
+* Returns `undefined` for anything else, including YouTube URLs that are not a
+* single video (channels, playlists) — those stay ordinary links.
+*/
+function parseYouTubeId(href) {
+	let url;
+	try {
+		url = new URL(href, "https://example.invalid");
+	} catch {
+		return;
+	}
+	const host = url.hostname.replace(/^(www|m)\./, "");
+	const segments = url.pathname.split("/").filter(Boolean);
+	if (host === "youtu.be") {
+		const [id] = segments;
+		return id !== void 0 && VIDEO_ID.test(id) ? id : void 0;
+	}
+	if (host !== "youtube.com" && host !== "youtube-nocookie.com") return;
+	if (url.pathname === "/watch") {
+		const id = url.searchParams.get("v");
+		return id !== null && VIDEO_ID.test(id) ? id : void 0;
+	}
+	const [prefix, id] = segments;
+	if ((prefix === "embed" || prefix === "shorts") && id !== void 0) return VIDEO_ID.test(id) ? id : void 0;
+}
+/** Whitespace-only text is what separates two links on consecutive lines. */
+function isIgnorable(node) {
+	return node.type === "text" && node.value.trim() === "";
+}
+/**
+* Is this link a BARE URL rather than a labelled one?
+*
+* `[the intro](https://youtu.be/x)` keeps its label and stays a link; only a
+* link whose visible text IS its own href becomes a video. Compared with the
+* scheme and any trailing slash removed, because a markdown autolink often
+* drops the scheme from the label.
+*/
+function isBareUrl(node) {
+	if (node.type !== "link" || node.children.length !== 1) return false;
+	const [only] = node.children;
+	if (only === void 0 || only.type !== "text") return false;
+	const strip = (value) => value.replace(HTTP_SCHEME, "").replace(/\/$/, "");
+	return strip(only.value) === strip(node.url);
+}
+/**
+* remark plugin. Replaces the whole PARAGRAPH, not the link inside it — which
+* is the point: leaving the paragraph is what nested a block element in
+* phrasing content.
+*
+* `data.hName` / `data.hProperties` is how `mdast-util-to-hast` is told to
+* serialise a node as something other than its default, so the output is a
+* plain hast element and the React layer maps it like any other.
+*/
+const remarkYouTube = () => {
+	return (tree) => {
+		visit(tree, "paragraph", (node, index, parent) => {
+			if (parent === void 0 || index === void 0) return;
+			const meaningful = node.children.filter((child) => !isIgnorable(child));
+			const only = meaningful[0];
+			if (meaningful.length !== 1 || only === void 0 || !isBareUrl(only)) return;
+			const id = only.type === "link" ? parseYouTubeId(only.url) : void 0;
+			if (id === void 0) return;
+			parent.children[index] = {
+				type: "paragraph",
+				children: [],
+				data: {
+					hName: "youtube",
+					hProperties: { id }
+				}
+			};
+			return [SKIP, index + 1];
+		});
+	};
+};
+//#endregion
+export { parseYouTubeId, remarkYouTube };

package/dist/react/callout.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from "react";
+//#region src/react/callout.d.ts
+/**
+ * The five alert kinds GitHub understands, which is also what
+ * `rehype-github-alerts` produces from `> [!NOTE]` and friends.
+ */
+declare const CALLOUT_TYPES: readonly ["note", "tip", "important", "warning", "caution"];
+/** One of {@link CALLOUT_TYPES}. */
+type CalloutType = (typeof CALLOUT_TYPES)[number];
+interface CalloutProps {
+  /**
+   * Kind of callout. Typed as a plain string because it arrives as an
+   * unvalidated hast attribute; anything unrecognised falls back to `note`
+   * rather than rendering an unstyled box.
+   */
+  type?: string | undefined;
+  /** Overrides the default label ("Note", "Warning", …). */
+  title?: string | undefined;
+  className?: string | undefined;
+  children?: ReactNode;
+}
+/**
+ * A note/tip/important/warning/caution block.
+ *
+ * Rendered as an `<aside role="note">`: `aside` is the honest element, and the
+ * explicit role keeps a callout in the middle of an article from showing up in
+ * every screen reader's landmark list. The type is carried on `aria-label`
+ * rather than left to the coloured border, which conveys nothing to a screen
+ * reader and nothing to the 8% of men who cannot separate the red one from the
+ * green one.
+ *
+ * All styling lives in `@waveso/docs/styles.css` under `.wave-docs-callout`,
+ * so consumers can restyle it without forking the component.
+ */
+declare function Callout({ type, title, className, children }: CalloutProps): ReactNode;
+//#endregion
+export { CALLOUT_TYPES, Callout, CalloutProps, CalloutType };

package/dist/react/callout.js

@@ -0,0 +1,113 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/react/callout.tsx
+/**
+* The five alert kinds GitHub understands, which is also what
+* `rehype-github-alerts` produces from `> [!NOTE]` and friends.
+*/
+const CALLOUT_TYPES = [
+	"note",
+	"tip",
+	"important",
+	"warning",
+	"caution"
+];
+const CALLOUT_LABELS = {
+	note: "Note",
+	tip: "Tip",
+	important: "Important",
+	warning: "Warning",
+	caution: "Caution"
+};
+/**
+* Lucide-derived glyph paths, drawn at 24×24 with a 2px stroke.
+*
+* Inlined rather than imported so the package takes no icon dependency and
+* ships no icon bytes for callouts a given page does not use.
+*/
+const CALLOUT_ICON_PATHS = {
+	note: ["M12 16v-4", "M12 8h.01"],
+	tip: [
+		"M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5a6 6 0 0 0-12 0c0 1.3.5 2.6 1.5 3.5.8.8 1.3 1.5 1.5 2.5",
+		"M9 18h6",
+		"M10 22h4"
+	],
+	important: [
+		"M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z",
+		"M12 7v4",
+		"M12 15h.01"
+	],
+	warning: [
+		"m21.73 18-8-14a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3",
+		"M12 9v4",
+		"M12 17h.01"
+	],
+	caution: [
+		"M15.31 2a2 2 0 0 1 1.42.59l4.68 4.68A2 2 0 0 1 22 8.69v6.62a2 2 0 0 1-.59 1.42l-4.68 4.68a2 2 0 0 1-1.42.59H8.69a2 2 0 0 1-1.42-.59l-4.68-4.68A2 2 0 0 1 2 15.31V8.69a2 2 0 0 1 .59-1.42l4.68-4.68A2 2 0 0 1 8.69 2z",
+		"M12 8v4",
+		"M12 16h.01"
+	]
+};
+/**
+* `note` is the only glyph whose enclosing shape is not already one of its
+* paths, so it gets a circle drawn before the strokes.
+*/
+const CALLOUT_ICON_CIRCLE = { note: true };
+function normalizeCalloutType(value) {
+	const candidate = value?.toLowerCase();
+	return CALLOUT_TYPES.find((type) => type === candidate) ?? "note";
+}
+/**
+* A note/tip/important/warning/caution block.
+*
+* Rendered as an `<aside role="note">`: `aside` is the honest element, and the
+* explicit role keeps a callout in the middle of an article from showing up in
+* every screen reader's landmark list. The type is carried on `aria-label`
+* rather than left to the coloured border, which conveys nothing to a screen
+* reader and nothing to the 8% of men who cannot separate the red one from the
+* green one.
+*
+* All styling lives in `@waveso/docs/styles.css` under `.wave-docs-callout`,
+* so consumers can restyle it without forking the component.
+*/
+function Callout({ type, title, className, children }) {
+	const kind = normalizeCalloutType(type);
+	const label = title?.trim() || CALLOUT_LABELS[kind];
+	return /* @__PURE__ */ jsxs("aside", {
+		role: "note",
+		"aria-label": label,
+		className: [
+			"wave-docs-callout",
+			`wave-docs-callout--${kind}`,
+			className
+		].filter(Boolean).join(" "),
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: "wave-docs-callout__label",
+			children: [/* @__PURE__ */ jsx(CalloutIcon, { type: kind }), label]
+		}), /* @__PURE__ */ jsx("div", {
+			className: "wave-docs-callout__body",
+			children
+		})]
+	});
+}
+function CalloutIcon({ type }) {
+	return /* @__PURE__ */ jsxs("svg", {
+		className: "wave-docs-callout__icon",
+		viewBox: "0 0 24 24",
+		width: "16",
+		height: "16",
+		fill: "none",
+		stroke: "currentColor",
+		strokeWidth: "2",
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		"aria-hidden": "true",
+		focusable: "false",
+		children: [CALLOUT_ICON_CIRCLE[type] ? /* @__PURE__ */ jsx("circle", {
+			cx: "12",
+			cy: "12",
+			r: "10"
+		}) : null, CALLOUT_ICON_PATHS[type].map((d) => /* @__PURE__ */ jsx("path", { d }, d))]
+	});
+}
+//#endregion
+export { CALLOUT_TYPES, Callout };

package/dist/react/doc-content.d.ts

@@ -0,0 +1,29 @@
+import { MarkdownComponents } from "./markdown-components.js";
+import { ReactNode } from "react";
+import { Root } from "hast";
+//#region src/react/doc-content.d.ts
+interface DocContentProps {
+  /**
+   * The tree from `@waveso/docs/render`. Plain serialisable JSON, so it
+   * crosses the RSC boundary and survives any build-time artifact intact.
+   */
+  hast: Root;
+  /** Overrides, merged over {@link defaultMarkdownComponents}. */
+  components?: MarkdownComponents | undefined;
+}
+/**
+ * Render a hast tree as React elements.
+ *
+ * Not a client component, and it must stay that way: the markdown parser and
+ * Shiki ran in Node at build time, and this component only walks the resulting
+ * tree. Nothing here pulls unified, remark or a highlighter into the browser.
+ *
+ * `passNode` is left off (the default). `react-markdown` hardcodes it *on* with
+ * no opt-out, so any mapped component that spreads its props renders
+ * `node="[object Object]"` into production HTML — with no type error to warn
+ * you, because `node` is a legal prop on the component and an unknown attribute
+ * on the element.
+ */
+declare function DocContent({ hast, components }: DocContentProps): ReactNode;
+//#endregion
+export { DocContent, DocContentProps };

package/dist/react/doc-content.js

@@ -0,0 +1,30 @@
+import { defaultMarkdownComponents } from "./markdown-components.js";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/react/doc-content.tsx
+/**
+* Render a hast tree as React elements.
+*
+* Not a client component, and it must stay that way: the markdown parser and
+* Shiki ran in Node at build time, and this component only walks the resulting
+* tree. Nothing here pulls unified, remark or a highlighter into the browser.
+*
+* `passNode` is left off (the default). `react-markdown` hardcodes it *on* with
+* no opt-out, so any mapped component that spreads its props renders
+* `node="[object Object]"` into production HTML — with no type error to warn
+* you, because `node` is a legal prop on the component and an unknown attribute
+* on the element.
+*/
+function DocContent({ hast, components }) {
+	return toJsxRuntime(hast, {
+		Fragment,
+		jsx,
+		jsxs,
+		components: {
+			...defaultMarkdownComponents,
+			...components
+		}
+	});
+}
+//#endregion
+export { DocContent };