nimbus-docs 0.1.11 → 0.1.12

package/dist/index.js

@@ -11,7 +11,7 @@ import { satteri } from "@astrojs/markdown-satteri";
 import sitemap from "@astrojs/sitemap";
 import fs$1, { cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { z } from "astro/zod";
-import { transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+import { transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
 import { createHash } from "node:crypto";
 
 //#region src/_internal/runtime-config.ts
@@ -419,6 +419,13 @@ function resolveConfigItems(configItems, entriesByCollection, primaryCollection,
 				badge: item.badge,
 				children
 			};
+			const landing = item.landing;
+			const segment = item.segment;
+			if (segment !== void 0) group.segment = segment;
+			if (landing !== void 0) {
+				group.indexHref = toBrowserHref(landing);
+				group.indexIsCurrent = toRouteKey(currentPath) === toRouteKey(landing) || void 0;
+			}
 			result.push(group);
 		}
 	}
@@ -459,6 +466,70 @@ function scopeToCurrentSection(items, currentPath) {
 	}
 	return items;
 }
+/**
+* Return the ancestor chain from the top of the tree to the node that owns
+* `currentPath` (inclusive). Matches by route key, so a chain can be
+* resolved for any path (e.g. a catalog route's section) regardless of the
+* page the tree was built for. A group that only *contains* the match is
+* included with no href (a non-interactive crumb). Returns `[]` on no match.
+*/
+function findActivePath(items, currentPath) {
+	const key = toRouteKey(currentPath);
+	function search(nodes) {
+		for (const item of nodes) if (item.type === "link") {
+			if (toRouteKey(item.href) === key) return [item];
+		} else if (item.type === "group") {
+			if (item.indexHref && !item.indexIsExternal && toRouteKey(item.indexHref) === key) return [item];
+			const childPath = search(item.children);
+			if (childPath) return [item, ...childPath];
+		}
+		return null;
+	}
+	return search(items) ?? [];
+}
+/**
+* Descend a section-scoped tree to the sub-tree under the current path's
+* boundary. A glob like `"guides/*"` (`*` = one segment) sets the prefix
+* depth; the rail is replaced by the children of the shallowest group
+* fully contained under that prefix. Matching is by descendant href, so it
+* works for index-less section folders. Returns the input unchanged on no
+* match.
+*/
+function isolateToBoundary(items, currentPath, boundaries) {
+	const segs = toRouteKey(currentPath).split("/").filter(Boolean);
+	for (const glob of boundaries) {
+		const globSegs = glob.split("/").filter(Boolean);
+		if (segs.length < globSegs.length || globSegs.length === 0) continue;
+		if (!globSegs.every((g, i) => g === "*" || g === segs[i])) continue;
+		const group = findBoundaryGroup(items, toBrowserHref("/" + segs.slice(0, globSegs.length).join("/")));
+		if (group) return group.children;
+	}
+	return items;
+}
+/** Shallowest group whose every flattened descendant href is under `prefix`. */
+function findBoundaryGroup(items, prefix) {
+	for (const item of items) {
+		if (item.type !== "group") continue;
+		const flat = flattenSidebar([item]);
+		if (flat.length > 0 && flat.every((l) => l.href.startsWith(prefix))) return item;
+		const nested = findBoundaryGroup(item.children, prefix);
+		if (nested) return nested;
+	}
+}
+/**
+* Context for the `getSidebar` transform: `sectionSlug` (seg0), `module`
+* (seg1), and `indexEntryId` — the landing entry id of the first group on
+* the active path, or `undefined` for an index-less section.
+*/
+function deriveTransformCtx(fullTree, currentSlug) {
+	const segs = currentSlug.split("/").filter(Boolean);
+	const sectionGroup = findActivePath(fullTree, currentSlug).find((n) => n.type === "group");
+	return {
+		sectionSlug: segs[0] ?? "",
+		module: segs[1],
+		indexEntryId: sectionGroup?._indexId
+	};
+}
 function hasActivePage(item, currentPath) {
 	if (item.type === "link") return item.isCurrent === true;
 	if (item.type === "external") return false;
@@ -581,7 +652,8 @@ function processHideChildren(items, entries) {
 				continue;
 			}
 			if (item._indexId && item.indexHref) {
-				if (entryById.get(item._indexId)?.data.sidebar?.hideChildren) {
+				const entry = entryById.get(item._indexId);
+				if (entry?.data.sidebar?.hideChildren || entry?.data.hideChildren) {
 					const replacement = item.indexIsExternal ? {
 						type: "external",
 						label: item.label,
@@ -871,7 +943,68 @@ function renderEntryAsMarkdown(entry, options = {}) {
 
 //#endregion
 //#region src/_internal/navigation.ts
-function getBreadcrumbs$1(slug, homeLabel = "Home") {
+/**
+* The in-site href a node links to, or `undefined` for a non-interactive
+* crumb (index-less groups and off-site landings).
+*/
+function nodeHref(node) {
+	if (node.type === "link") return node.href;
+	if (node.type === "external") return void 0;
+	return node.indexIsExternal ? void 0 : node.indexHref;
+}
+/**
+* Build the trail from the root crumb and per-node labels. `labels[i]`
+* pairs with `path[i]`: `null` drops the crumb, `undefined` keeps the
+* node label. Deduplicated by href (first wins); hrefless crumbs are
+* never merged.
+*/
+function assembleBreadcrumbs(root, path, labels) {
+	const crumbs = [{
+		label: root.label,
+		href: root.href
+	}];
+	path.forEach((node, i) => {
+		const override = labels[i];
+		if (override === null) return;
+		const label = override ?? node.label;
+		const href = nodeHref(node);
+		crumbs.push(href ? {
+			label,
+			href
+		} : { label });
+	});
+	const seen = /* @__PURE__ */ new Set();
+	return crumbs.filter((c) => {
+		if (c.href === void 0) return true;
+		if (seen.has(c.href)) return false;
+		seen.add(c.href);
+		return true;
+	});
+}
+/**
+* Append `trail` items to a section's ancestry crumbs (a leaf with no
+* `href` is the current page) and deduplicate by href, so a trail crumb
+* that repeats an ancestry crumb's URL collapses to one (first wins). The
+* pure core of `getRouteNavigation`.
+*/
+function composeRouteBreadcrumbs(sectionCrumbs, trail) {
+	const combined = [...sectionCrumbs, ...trail.map((t) => t.href ? {
+		label: t.label,
+		href: t.href
+	} : { label: t.label })];
+	const seen = /* @__PURE__ */ new Set();
+	return combined.filter((c) => {
+		if (c.href === void 0) return true;
+		if (seen.has(c.href)) return false;
+		seen.add(c.href);
+		return true;
+	});
+}
+/**
+* URL-segment fallback for pages with no node in the tree, so a stray
+* page still gets a root-anchored trail.
+*/
+function breadcrumbsFromUrl(slug, homeLabel = "Home") {
 	const parts = slug.split("/").filter(Boolean);
 	const crumbs = [{
 		label: homeLabel,
@@ -1028,30 +1161,48 @@ function transformAdmonitions(source, options = {}) {
 	};
 	const { frontmatter, body, bodyOffset: _ } = splitFrontmatter(source);
 	const { stashed, restore } = stashCodeBlocks(body);
-	return frontmatter + restore(stashed.replace(ADMONITION_PATTERN, (match, rawType, rawTitle, rawContent) => {
+	return frontmatter + restore(stashed.replace(ADMONITION_PATTERN, (match, rawIndent, rawType, rawTitle, rawContent) => {
 		const aside = typeMap[String(rawType).toLowerCase()];
 		if (!aside) return match;
+		const indent = typeof rawIndent === "string" ? rawIndent : "";
 		const title = typeof rawTitle === "string" ? rawTitle.trim() : "";
-		const content = String(rawContent).trim();
-		return `\n\n<Aside type="${aside}"${title ? ` title=${JSON.stringify(title)}` : ""}>\n\n${content}\n\n</Aside>\n\n`;
+		return `\n\n${indent}<Aside type="${aside}"${title ? ` title=${JSON.stringify(title)}` : ""}>\n\n${reindentBody(String(rawContent), indent)}\n\n${indent}</Aside>\n\n`;
 	}));
 }
 /**
 * Match `:::type[optional title] body :::` with non-greedy body.
 *
 * Components:
+*   - `^([ \t]*)`     leading indentation of the opener line (captured) so the
+*                      emitted `<Aside>` can be re-indented to the same depth —
+*                      load-bearing for directives nested inside indented JSX
+*                      (e.g. `:::note` inside a `<TabItem>`). The `m` flag makes
+*                      `^`/`$` match line boundaries. Line-anchoring also stops
+*                      a stray mid-line `:::` from being treated as an opener.
 *   - `:::`           literal opener
 *   - `([a-zA-Z]+)`   type token (captured, case-insensitive lookup at use site)
 *   - `(?:\[(...)\])?` optional bracketed title; brackets stripped from capture
-*   - `\s+|\n`        at least one whitespace before content (avoids matching
+*   - `\n|[ \t]+`     at least one whitespace before content (avoids matching
 *                      `:::foo:::` directly)
 *   - `([\s\S]*?)`    non-greedy body, may span newlines
-*   - `\n?\s*:::`     closer, possibly with leading whitespace
+*   - `\n?[ \t]*:::[ \t]*$`  closer, possibly indented, at end of its line
 *
 * Non-greedy body + global flag means adjacent admonitions don't merge
 * (the engine finds the *nearest* `:::` closer for each opener).
 */
-const ADMONITION_PATTERN = /:::([a-zA-Z]+)(?:\[([^\]]*)\])?[ \t]*(?:\n|[ \t]+)([\s\S]*?)\n?[ \t]*:::/g;
+const ADMONITION_PATTERN = /^([ \t]*):::([a-zA-Z]+)(?:\[([^\]]*)\])?[ \t]*(?:\n|[ \t]+)([\s\S]*?)\n?[ \t]*:::[ \t]*$/gm;
+/**
+* Dedent the captured admonition body to a common baseline (preserving
+* relative structure like nested lists / JSX), then re-prefix every
+* non-blank line with the directive's own indentation so the emitted
+* `<Aside>…</Aside>` block sits at the same depth as the directive.
+*/
+function reindentBody(content, indent) {
+	const lines = content.replace(/^\n+/, "").replace(/\n+$/, "").split("\n");
+	const widths = lines.filter((l) => l.trim() !== "").map((l) => l.match(/^[ \t]*/)?.[0].length ?? 0);
+	const common = widths.length ? Math.min(...widths) : 0;
+	return lines.map((l) => l.trim() === "" ? "" : indent + l.slice(common)).join("\n");
+}
 function splitFrontmatter(source) {
 	const match = source.match(/^---\n[\s\S]*?\n---\n?/);
 	if (!match) return {
@@ -1711,6 +1862,118 @@ function parseTitle(meta) {
 	return (meta.match(/\btitle="([^"]+)"/) ?? meta.match(/\btitle='([^']+)'/))?.[1];
 }
 /**
+* Expand a (possibly space-padded) line-range spec like `5-16, 21-40` or
+* `1,3-5` into an explicit list of 1-based line numbers. Tolerates spaces
+* anywhere — `{5-16, 21-40}` expands to the same set as `{5-16,21-40}`.
+*/
+function expandRanges(spec) {
+	const out = [];
+	for (const partRaw of spec.split(",")) {
+		const part = partRaw.trim();
+		if (!part) continue;
+		const range = part.match(/^(\d+)\s*-\s*(\d+)$/);
+		if (range) {
+			const a = Number.parseInt(range[1], 10);
+			const b = Number.parseInt(range[2], 10);
+			const lo = Math.min(a, b);
+			const hi = Math.max(a, b);
+			for (let i = lo; i <= hi; i++) out.push(i);
+		} else if (/^\d+$/.test(part)) out.push(Number.parseInt(part, 10));
+	}
+	return out;
+}
+/**
+* Parse an EC-style fence meta string into {@link NimbusMeta}.
+*
+* Order matters — each step consumes (blanks out) what it matched so later,
+* looser patterns can't re-grab it:
+*   1. `frame="…"`            (quoted)
+*   2. `title="…"`            (quoted; value resolved separately)
+*   3. `ins="…"` / `del="…"`  (quoted tokens)
+*   4. `ins={…}` / `del={…}` / `collapse={…}`  (brace ranges)
+*   5. standalone `"…"`/`'…'` (search words — what's left of the quotes)
+*   6. `wrap`                 (bare keyword)
+*   7. bare `{…}`             (plain line-highlight — only what survives)
+*/
+function parseNimbusMeta(raw) {
+	const meta = {
+		highlightLines: /* @__PURE__ */ new Set(),
+		insLines: /* @__PURE__ */ new Set(),
+		delLines: /* @__PURE__ */ new Set(),
+		insTokens: [],
+		delTokens: [],
+		searchWords: [],
+		collapseLines: /* @__PURE__ */ new Set(),
+		wrap: false,
+		frame: void 0
+	};
+	if (!raw) return meta;
+	let s = raw;
+	s = s.replace(/\bframe=(?:"([^"]*)"|'([^']*)')/g, (_m, d, sg) => {
+		const v = d ?? sg;
+		if (v) meta.frame = v;
+		return " ";
+	});
+	s = s.replace(/\btitle=(?:"([^"]*)"|'([^']*)')/g, () => " ");
+	s = s.replace(/\bins=(?:"([^"]*)"|'([^']*)')/g, (_m, d, sg) => {
+		const v = d ?? sg;
+		if (v) meta.insTokens.push(v);
+		return " ";
+	});
+	s = s.replace(/\bdel=(?:"([^"]*)"|'([^']*)')/g, (_m, d, sg) => {
+		const v = d ?? sg;
+		if (v) meta.delTokens.push(v);
+		return " ";
+	});
+	s = s.replace(/\bins=\{([^}]*)\}/g, (_m, spec) => {
+		for (const n of expandRanges(spec)) meta.insLines.add(n);
+		return " ";
+	});
+	s = s.replace(/\bdel=\{([^}]*)\}/g, (_m, spec) => {
+		for (const n of expandRanges(spec)) meta.delLines.add(n);
+		return " ";
+	});
+	s = s.replace(/\bcollapse=\{([^}]*)\}/g, (_m, spec) => {
+		for (const n of expandRanges(spec)) meta.collapseLines.add(n);
+		return " ";
+	});
+	for (const m of s.matchAll(/"([^"]*)"|'([^']*)'/g)) {
+		const v = m[1] ?? m[2];
+		if (v) meta.searchWords.push(v);
+	}
+	s = s.replace(/"[^"]*"|'[^']*'/g, " ");
+	s = s.replace(/\bwrap\b/g, () => {
+		meta.wrap = true;
+		return " ";
+	});
+	s = s.replace(/\{([^}]*)\}/g, (_m, spec) => {
+		for (const n of expandRanges(spec)) meta.highlightLines.add(n);
+		return " ";
+	});
+	return meta;
+}
+/** Collect the plain-text content of a hast line node (concatenates spans). */
+function lineText(node) {
+	if (node.type === "text") return node.value ?? "";
+	let out = "";
+	if ("children" in node && node.children) for (const child of node.children) out += lineText(child);
+	return out;
+}
+/** Find every (non-overlapping) start index of `substr` in `str`. */
+function findAllSubstringIndexes(str, substr) {
+	const out = [];
+	if (!substr) return out;
+	let cursor = 0;
+	for (;;) {
+		const index = str.indexOf(substr, cursor);
+		if (index === -1) break;
+		out.push(index);
+		cursor = index + substr.length;
+	}
+	return out;
+}
+const META_SYMBOL = Symbol("nimbus-meta");
+/**
 * The canonical Shiki transformer chain for Nimbus. Returns a fresh
 * array each call so callers don't accidentally mutate a shared list.
 *
@@ -1727,11 +1990,57 @@ function defaultCodeTransformers() {
 		transformerNotationFocus(),
 		transformerNotationErrorLevel(),
 		transformerNotationWordHighlight(),
-		transformerMetaHighlight(),
-		transformerMetaWordHighlight(),
+		nimbusMetaTransformer(),
 		titleAndLangTransformer()
 	];
 }
+/**
+* Nimbus-owned fence-meta transformer. Owns bare-brace highlight
+* (space-tolerant), `ins=`/`del=` (brace + quoted-string forms),
+* quoted-search word highlight, `wrap`, `collapse` (neutral), and a
+* `frame=` hook. Replaces the stock meta-highlight + meta-word-highlight
+* transformers, which double-fired and hijacked braces.
+*/
+function nimbusMetaTransformer() {
+	function getMeta(ctx) {
+		const carrier = ctx.meta ?? {};
+		if (!carrier[META_SYMBOL]) carrier[META_SYMBOL] = parseNimbusMeta(ctx.options.meta?.__raw);
+		return carrier[META_SYMBOL];
+	}
+	return {
+		name: "nimbus:meta",
+		preprocess(code, options) {
+			if (!this.options.meta?.__raw) return;
+			const meta = getMeta(this);
+			if (meta.searchWords.length === 0) return;
+			options.decorations ||= [];
+			for (const word of meta.searchWords) for (const index of findAllSubstringIndexes(code, word)) options.decorations.push({
+				start: index,
+				end: index + word.length,
+				properties: { class: "highlighted-word" }
+			});
+		},
+		line(node, lineNumber) {
+			if (!this.options.meta?.__raw) return;
+			const meta = getMeta(this);
+			if (meta.highlightLines.has(lineNumber)) this.addClassToHast(node, "highlighted");
+			if (meta.insLines.has(lineNumber)) this.addClassToHast(node, "diff add");
+			if (meta.delLines.has(lineNumber)) this.addClassToHast(node, "diff remove");
+			if (meta.insTokens.length || meta.delTokens.length) {
+				const text = lineText(node);
+				if (meta.insTokens.some((t) => text.includes(t))) this.addClassToHast(node, "diff add");
+				if (meta.delTokens.some((t) => text.includes(t))) this.addClassToHast(node, "diff remove");
+			}
+		},
+		pre(preNode) {
+			if (!this.options.meta?.__raw) return;
+			const meta = getMeta(this);
+			preNode.properties = preNode.properties ?? {};
+			if (meta.wrap) preNode.properties["data-nb-wrap"] = "";
+			if (meta.frame) preNode.properties["data-nb-frame"] = meta.frame;
+		}
+	};
+}
 function titleAndLangTransformer() {
 	return {
 		name: "nimbus:title-and-lang",
@@ -1741,6 +2050,8 @@ function titleAndLangTransformer() {
 			const title = parseTitle(meta);
 			preNode.properties = preNode.properties ?? {};
 			preNode.properties["data-nb-lang"] = lang;
+			const wrap = preNode.properties["data-nb-wrap"] !== void 0;
+			const frame = preNode.properties["data-nb-frame"];
 			const children = [];
 			if (title) children.push({
 				type: "element",
@@ -1765,13 +2076,16 @@ function titleAndLangTransformer() {
 				}]
 			});
 			children.push(preNode);
+			const figureProps = {
+				class: title ? "nb-code-figure nb-code-figure-titled" : "nb-code-figure",
+				"data-nb-lang": lang
+			};
+			if (wrap) figureProps["data-nb-wrap"] = "";
+			if (typeof frame === "string") figureProps["data-nb-frame"] = frame;
 			return {
 				type: "element",
 				tagName: "figure",
-				properties: {
-					class: title ? "nb-code-figure nb-code-figure-titled" : "nb-code-figure",
-					"data-nb-lang": lang
-				},
+				properties: figureProps,
 				children
 			};
 		}
@@ -4201,8 +4515,19 @@ async function getIndexedTopLevel() {
 */
 async function getSidebar(currentSlug, options) {
 	const config = await loadNimbusConfig();
-	const tree = await buildFullSidebarTree(currentSlug, options?.collection);
-	return config.sidebar?.scope === "section" ? scopeToCurrentSection(tree, currentSlug) : tree;
+	const fullTree = await buildFullSidebarTree(currentSlug, options?.collection);
+	let tree = config.sidebar?.scope === "section" ? scopeToCurrentSection(fullTree, currentSlug) : fullTree;
+	const boundaries = config.sidebar?.isolate?.boundaries;
+	if (boundaries && boundaries.length > 0) tree = isolateToBoundary(tree, currentSlug, boundaries);
+	if (options?.transform) {
+		const ctx = deriveTransformCtx(fullTree, currentSlug);
+		tree = await options.transform({
+			tree,
+			currentSlug,
+			...ctx
+		});
+	}
+	return tree;
 }
 /**
 * Derive one section per top-level group in the sidebar — used by
@@ -4293,13 +4618,74 @@ async function getPrevNext(currentSlug, options) {
 	return getPrevNext$1(currentSlug, tree, options?.overrides, validInternalLinks);
 }
 /**
-* Build breadcrumb trail from "/" to the current page.
-*
-* Simple URL-segment derivation. A later iteration may enrich this with
-* sidebar-aware labels.
+* Build the breadcrumb trail from the active node's ancestry in the nav
+* tree. Labels come from nav nodes, hrefs from each node's landing — so a
+* section crumb links to its real landing page and segments with no node
+* never appear. Index-less folders render as non-interactive crumbs.
+*
+* - `collection` — the page's Astro collection; pass `entry.collection` so
+*   versioned pages get version-prefixed hrefs.
+* - `root` — the leading crumb (default `{ label: "Home", href: "/" }`).
+* - `resolveLabel` — override a crumb label, or return `null` to drop it.
+*
+* Falls back to URL-segment derivation when the page has no node in the
+* tree, so a stray page still gets a root-anchored trail.
 */
 async function getBreadcrumbs(currentSlug, options) {
-	return getBreadcrumbs$1(currentSlug, options?.homeLabel ?? "Home");
+	const path = findActivePath(await buildFullSidebarTree(currentSlug, options?.collection), currentSlug);
+	if (path.length > 0) return assembleBreadcrumbs(options?.root ?? {
+		label: "Home",
+		href: "/"
+	}, path, await Promise.all(path.map((node) => Promise.resolve(options?.resolveLabel?.({
+		node,
+		slug: currentSlug
+	})))));
+	return breadcrumbsFromUrl(currentSlug, options?.root?.label ?? "Home");
+}
+/**
+* Resolve a section's display title(s) for the current page, decoupled so
+* the rail header and the breadcrumb can differ.
+*
+* Derives `sectionSlug` (seg0) and `module` (seg1) from the slug and passes
+* them to a caller-supplied resolver. The resolver is an argument rather
+* than config because config is JSON-serialized and cannot carry functions.
+* `indexEntryId` is currently always `undefined`.
+*/
+async function getSectionTitle(currentSlug, resolve) {
+	const segs = currentSlug.split("/").filter(Boolean);
+	const sectionSlug = segs[0];
+	if (!sectionSlug) return void 0;
+	return resolve({
+		sectionSlug,
+		module: segs[1],
+		indexEntryId: void 0
+	});
+}
+/**
+* Navigation (breadcrumbs, sidebar active-state, optional prev/next) for a
+* data-driven route with no content entry of its own — e.g. a catalog page
+* under `src/pages/[...].astro`.
+*
+* Builds the breadcrumb trail to `section` (a real nav node) and appends
+* `trail` (the leaf). The sidebar is built with `section` as the active
+* path, so the section node highlights even though the leaf is not in the
+* tree — the leaf is never injected, keeping the tree and prev/next clean.
+*/
+async function getRouteNavigation(options) {
+	const { section, trail = [], prevNext = false, collection, resolveLabel } = options;
+	const sidebar = await getSidebar(section, { collection });
+	const breadcrumbs = composeRouteBreadcrumbs(await getBreadcrumbs(section, {
+		collection,
+		resolveLabel
+	}), trail);
+	let pn;
+	if (prevNext) pn = await getPrevNext(section, { sidebarTree: sidebar });
+	return {
+		breadcrumbs,
+		sidebar,
+		activeHref: section,
+		prevNext: pn
+	};
 }
 /**
 * Build an edit URL for a content entry using `config.editPattern`.
@@ -4651,5 +5037,5 @@ async function getVersionStatus(collectionId) {
 }
 
 //#endregion
-export { nimbus as default, defaultCodeTransformers, defineConfig, getBreadcrumbs, getCanonicalUrl, getCollectionLlmsUrl, getCollectionPageProps, getCollectionStaticPaths, getCurrentVersion, getDocsPageProps, getDocsStaticPaths, getEditUrl, getIndexedEntries, getIndexedTopLevel, getLastUpdated, getPrevNext, getSidebar, getSidebarSections, getTOC, getVersionAlternates, getVersionLandingUrl, getVersionStatus, getVersions, getVisibleEntries, renderEntryAsMarkdown, sidebarHash };
+export { nimbus as default, defaultCodeTransformers, defineConfig, getBreadcrumbs, getCanonicalUrl, getCollectionLlmsUrl, getCollectionPageProps, getCollectionStaticPaths, getCurrentVersion, getDocsPageProps, getDocsStaticPaths, getEditUrl, getIndexedEntries, getIndexedTopLevel, getLastUpdated, getPrevNext, getRouteNavigation, getSectionTitle, getSidebar, getSidebarSections, getTOC, getVersionAlternates, getVersionLandingUrl, getVersionStatus, getVersions, getVisibleEntries, renderEntryAsMarkdown, sidebarHash };
 //# sourceMappingURL=index.js.map