imprensa 0.1.0

package/dist/index.mjs

@@ -0,0 +1,668 @@
+import { THEME_STORAGE_KEY, applyInitialTheme, applyThemeToHtml, createImprensa, getStoredTheme, mountOrHydrate, setStoredTheme, shiki, shikiThemes } from "./core/client-runtime.mjs";
+import { i as resolveShikiThemeIds, n as codeToSnippetHtml, r as resolveShikiLangs, t as createPrerender } from "./prerender-core-D4Li--RS.mjs";
+import { createConfiguredHighlighterCore, resolveShikiLangModuleHref, resolveShikiThemeModuleHref } from "./core/shiki-build.mjs";
+import { n as toStringArray, t as parseScalar } from "./frontmatter-DVneGjCO.mjs";
+import { n as SIDEBAR_LAYOUT_BOOT_SCRIPT } from "./sidebar-layout-DsEhSkJS.mjs";
+import { t as rehypeDeadLinks } from "./rehype-BWpGaBql.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { pages } from "@ilha/router/vite";
+import mdx from "@mdx-js/rollup";
+import tailwindcss from "@tailwindcss/vite";
+import rehypeAutolinkHeadings from "rehype-autolink-headings";
+import rehypeSlug from "rehype-slug";
+import { vitePrerenderPlugin } from "vite-prerender-plugin";
+import sitemap from "vite-plugin-sitemap";
+import fs, { existsSync } from "node:fs";
+import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
+import { transformerTwoslash } from "@shikijs/twoslash";
+//#region src/core/routes.ts
+function normalizeContentDirPhysical$1(root, dir) {
+	const trimmed = dir.replace(/^\/+|\/+$/g, "").replace(/^src\//, "");
+	return path.join(root, "src", trimmed);
+}
+function normalizeContentDir(dir) {
+	return `/src/${dir.replace(/^\/+|\/+$/g, "").replace(/^src\//, "")}/`;
+}
+function filePathToRoutePathFromDisk(filePath, contentDirPhysical) {
+	const relative = path.relative(contentDirPhysical, filePath).replace(/\\/g, "/").replace(/\.mdx?$/, "").replace(/\/index$/, "");
+	if (!relative || relative === "index") return "/";
+	return `/${relative}`;
+}
+function collectRawMdxSources(root, contentDirOption) {
+	const contentDirPhysical = normalizeContentDirPhysical$1(root, contentDirOption);
+	if (!fs.existsSync(contentDirPhysical)) return {};
+	const sources = {};
+	function walk(dir) {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(entryPath);
+				continue;
+			}
+			if (!/\.mdx?$/.test(entry.name)) continue;
+			sources[filePathToRoutePathFromDisk(entryPath, contentDirPhysical)] = fs.readFileSync(entryPath, "utf8");
+		}
+	}
+	walk(contentDirPhysical);
+	return sources;
+}
+function collectMdxRoutes(contentDirOption, root = process.cwd()) {
+	const contentDirPhysical = normalizeContentDirPhysical$1(root, contentDirOption);
+	if (!fs.existsSync(contentDirPhysical)) return [];
+	const routes = [];
+	function walk(dir) {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(entryPath);
+				continue;
+			}
+			if (!/\.mdx?$/.test(entry.name)) continue;
+			routes.push(filePathToRoutePathFromDisk(entryPath, contentDirPhysical));
+		}
+	}
+	walk(contentDirPhysical);
+	return routes;
+}
+//#endregion
+//#region src/core/shiki.ts
+const require = createRequire(import.meta.url);
+function resolveImportSpecifier(id) {
+	return pathToFileURL(require.resolve(id)).href;
+}
+function getShikiHighlighterOptions(options) {
+	if (options === false) return {
+		themes: ["night-owl-light", "houston"],
+		langs: ["typescript"],
+		clientShiki: false
+	};
+	const shiki = options ?? {};
+	return {
+		themes: resolveShikiThemeIds(shiki),
+		langs: resolveShikiLangs(shiki),
+		clientShiki: shiki.clientShiki !== false
+	};
+}
+function shikiPlugin(options) {
+	if (options === false) return [];
+	const { twoslash = true, transformers = [], themes, langs: _langs, clientShiki: _client, ...rest } = options ?? {};
+	const themeIds = resolveShikiThemeIds(options);
+	const langIds = resolveShikiLangs(options);
+	const themeRecord = themes ?? {
+		light: "night-owl-light",
+		dark: "houston"
+	};
+	return [function rehypeShikiConfigured() {
+		return async (tree) => {
+			return rehypeShikiFromHighlighter(await createConfiguredHighlighterCore(themeIds, langIds), {
+				themes: themeRecord,
+				langs: langIds,
+				...rest,
+				transformers: twoslash ? [transformerTwoslash({ explicitTrigger: true }), ...transformers] : transformers
+			})(tree);
+		};
+	}];
+}
+/**
+* Browser virtual module: static imports for configured themes only;
+* each configured lang is a separate dynamic import (no Shiki language catalog).
+*/
+function shikiFineGrainedRuntime(options) {
+	const themes = [...new Set(options.themes)];
+	const langs = [...new Set(options.langs.map((l) => l === "ts" ? "typescript" : l))];
+	const themeImports = themes.map((theme, index) => {
+		const href = resolveShikiThemeModuleHref(theme);
+		return `import theme${index} from ${JSON.stringify(href)};`;
+	});
+	const langCases = langs.map((lang) => {
+		const href = resolveShikiLangModuleHref(lang);
+		return `case ${JSON.stringify(lang)}: return import(${JSON.stringify(href)});`;
+	}).join("\n          ");
+	const shikiCore = resolveImportSpecifier("shiki/core");
+	const shikiEngine = resolveImportSpecifier("shiki/engine/javascript");
+	const allowedJson = JSON.stringify(langs);
+	return `
+        import { createHighlighterCore } from ${JSON.stringify(shikiCore)};
+        import { createJavaScriptRegexEngine } from ${JSON.stringify(shikiEngine)};
+        ${themeImports.join("\n        ")}
+        const __allowedLangs = new Set(${allowedJson});
+        async function __importLang(lang) {
+          const id = lang === "ts" ? "typescript" : lang;
+          if (!__allowedLangs.has(id)) {
+            throw new Error(
+              \`imprensa/shiki: language "\${lang}" is not in shiki.langs. Add it under imprensa({ shiki: { langs: [...] } }) in vite.config.\`,
+            );
+          }
+          switch (id) {
+          ${langCases || `default: throw new Error(\`shiki.langs is empty\`);`}
+          default:
+            throw new Error(\`imprensa/shiki: missing lazy import for "\${id}"\`);
+          }
+        }
+        const __core = await createHighlighterCore({
+          themes: [${themes.map((_, index) => `theme${index}`).join(", ")}],
+          langs: [],
+          engine: createJavaScriptRegexEngine(),
+        });
+        const __loaded = new Set();
+        export const shiki = {
+          loadLanguage: async (lang) => {
+            const id = lang === "ts" ? "typescript" : lang;
+            if (__loaded.has(id)) return;
+            const mod = await __importLang(lang);
+            await __core.loadLanguage(mod.default ?? mod);
+            __loaded.add(id);
+          },
+          codeToHtml: (code, opts) => __core.codeToHtml(code, opts),
+        };`;
+}
+//#endregion
+//#region src/docs/llms.ts
+function normalizeContentDirPhysical(root, contentDir) {
+	const trimmed = contentDir.replace(/^\/+|\/+$/g, "").replace(/^src\//, "");
+	return path.join(root, "src", trimmed);
+}
+function filePathToRoutePath(filePath, contentDirPhysical) {
+	const relative = path.relative(contentDirPhysical, filePath).replace(/\\/g, "/").replace(/\.mdx?$/, "").replace(/\/index$/, "");
+	if (!relative || relative === "index") return "/";
+	return `/${relative}`;
+}
+function titleize(value) {
+	return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function parseFrontmatter(content) {
+	if (!content.startsWith("---")) return {};
+	const end = content.indexOf("\n---", 3);
+	if (end === -1) return {};
+	const yaml = content.slice(4, end);
+	const meta = {};
+	let listKey;
+	for (const line of yaml.split("\n")) {
+		const listItem = line.match(/^\s*-\s*(.+)$/);
+		if (listItem && listKey) {
+			const existing = meta[listKey];
+			const list = Array.isArray(existing) ? [...existing] : [];
+			list.push(parseScalar(listItem[1]));
+			meta[listKey] = list;
+			continue;
+		}
+		const m = line.match(/^([\w-]+):\s*(.*)$/);
+		if (!m) continue;
+		listKey = void 0;
+		if (!m[2].trim()) {
+			meta[m[1]] = [];
+			listKey = m[1];
+		} else meta[m[1]] = parseScalar(m[2]);
+	}
+	return {
+		title: typeof meta.title === "string" ? meta.title : void 0,
+		description: typeof meta.description === "string" ? meta.description : void 0,
+		order: typeof meta.order === "number" ? meta.order : void 0,
+		priority: typeof meta.priority === "number" ? meta.priority : void 0,
+		type: meta.type === "custom" || meta.type === "link" ? meta.type : "doc",
+		draft: meta.draft === true,
+		hidden: meta.hidden === true || meta.sidebar === false,
+		tags: toStringArray(meta.tags)
+	};
+}
+function stripFrontmatter(content) {
+	if (!content.startsWith("---")) return content;
+	const end = content.indexOf("\n---", 3);
+	return end === -1 ? content : content.slice(end + 4).replace(/^\s+/, "");
+}
+function titleFromSource(content, filePath, meta) {
+	if (meta.title) return meta.title;
+	const heading = stripFrontmatter(content).match(/^#\s+(.+)$/m);
+	if (heading) return heading[1].trim();
+	const name = path.basename(filePath).replace(/\.mdx?$/, "");
+	return titleize(name === "index" ? "overview" : name);
+}
+function routeToDistRelative(routePath) {
+	if (routePath === "/") return "index.md";
+	return `${routePath.slice(1)}/index.md`;
+}
+function collectContentFiles(contentDirPhysical) {
+	if (!fs.existsSync(contentDirPhysical)) return [];
+	const files = [];
+	function walk(dir) {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(entryPath);
+				continue;
+			}
+			if (!/\.mdx?$/.test(entry.name)) continue;
+			const content = fs.readFileSync(entryPath, "utf8");
+			const meta = parseFrontmatter(content);
+			if (meta.draft || meta.hidden || meta.type === "link") continue;
+			const routePath = filePathToRoutePath(entryPath, contentDirPhysical);
+			files.push({
+				sourcePath: entryPath,
+				routePath,
+				distRelative: routeToDistRelative(routePath),
+				title: titleFromSource(content, entryPath, meta),
+				description: meta.description,
+				order: meta.order,
+				content: stripFrontmatter(content),
+				ext: ".md",
+				tags: meta.tags ?? []
+			});
+		}
+	}
+	walk(contentDirPhysical);
+	return files.sort((a, b) => {
+		if (a.order !== void 0 || b.order !== void 0) return (a.order ?? 9999) - (b.order ?? 9999);
+		return a.routePath.localeCompare(b.routePath);
+	});
+}
+function renderLlmsOutline(files, options) {
+	const lines = [
+		`# ${options.siteName}`,
+		"",
+		`> ${options.summary}`,
+		"",
+		`## ${options.section}`,
+		""
+	];
+	for (const file of files) {
+		const description = file.description ? `: ${file.description}` : "";
+		lines.push(`- [${file.title}](/${file.distRelative})${description}`);
+	}
+	lines.push("", "## Full text", "", "- [llms-full.txt](/llms-full.txt): Complete documentation dump");
+	return `${lines.join("\n")}\n`;
+}
+function renderLlmsFull(files) {
+	return files.map((file) => {
+		return [
+			`# ${file.title}`,
+			"",
+			`Route: ${file.routePath}`,
+			`Source: /${file.distRelative}`,
+			"",
+			file.content
+		].join("\n");
+	}).join("\n\n---\n\n").concat("\n");
+}
+function readSiteName(root) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+		if (pkg.name) return titleize(pkg.name.replace(/^@[^/]+\//, "").replace(/-/g, " "));
+	} catch {}
+	return "Documentation";
+}
+function generateLlmsArtifacts(options) {
+	if (options.llms === false) return;
+	const root = options.root ?? process.cwd();
+	const files = collectContentFiles(normalizeContentDirPhysical(root, options.contentDir));
+	if (files.length === 0) return;
+	const llmsOptions = typeof options.llms === "object" ? options.llms : {};
+	const resolved = {
+		siteName: llmsOptions.siteName ?? readSiteName(root),
+		summary: llmsOptions.summary ?? "Documentation site generated by imprensa.",
+		section: llmsOptions.section ?? "Docs"
+	};
+	fs.mkdirSync(options.outDir, { recursive: true });
+	for (const file of files) {
+		const distPath = path.join(options.outDir, file.distRelative);
+		fs.mkdirSync(path.dirname(distPath), { recursive: true });
+		fs.copyFileSync(file.sourcePath, distPath);
+	}
+	fs.writeFileSync(path.join(options.outDir, "llms.txt"), renderLlmsOutline(files, resolved));
+	fs.writeFileSync(path.join(options.outDir, "llms-full.txt"), renderLlmsFull(files));
+	fs.writeFileSync(path.join(options.outDir, "llms.json"), `${JSON.stringify({
+		siteName: resolved.siteName,
+		summary: resolved.summary,
+		section: resolved.section,
+		pages: files.map(({ content: _content, sourcePath: _sourcePath, ...file }) => file)
+	}, null, 2)}\n`);
+}
+//#endregion
+//#region src/docs/mdx-config.ts
+const MDX_CONFIG_MARKER = `declare const __IMPRENSA_CONTENT_DIR__: string;
+declare const __IMPRENSA_REPO__: string;
+declare const __IMPRENSA_REPO_BRANCH__: string;
+declare const __IMPRENSA_REPO_PATH__: string;
+declare const __IMPRENSA_RAW_SOURCES__: Record<string, string>;
+declare const __IMPRENSA_HEAD_DEFAULTS__: Head | null;
+
+export const contentDir = __IMPRENSA_CONTENT_DIR__;
+export const imprensaRepo = __IMPRENSA_REPO__;
+export const imprensaRepoBranch = __IMPRENSA_REPO_BRANCH__;
+export const imprensaRepoPath = __IMPRENSA_REPO_PATH__;
+export const mdxRawSources: Record<string, string> = __IMPRENSA_RAW_SOURCES__;
+export const headDefaults: Head | null = __IMPRENSA_HEAD_DEFAULTS__;`;
+//#endregion
+//#region src/docs/remark.ts
+function isCode(node) {
+	return node.type === "code";
+}
+function remarkPreview() {
+	return (tree) => {
+		let hasPreview = false;
+		tree.children = tree.children.map((node) => {
+			if (!isCode(node) || !(node.meta ?? "").includes("preview")) return node;
+			hasPreview = true;
+			return {
+				type: "mdxJsxFlowElement",
+				name: "Preview",
+				attributes: [{
+					type: "mdxJsxAttribute",
+					name: "code64",
+					value: {
+						type: "mdxJsxAttributeValueExpression",
+						value: JSON.stringify(Buffer.from(node.value).toString("base64")),
+						data: { estree: {
+							type: "Program",
+							body: [{
+								type: "ExpressionStatement",
+								expression: {
+									type: "Literal",
+									value: Buffer.from(node.value).toString("base64")
+								}
+							}],
+							sourceType: "module"
+						} }
+					}
+				}],
+				children: []
+			};
+		});
+		if (!hasPreview) return;
+		tree.children.unshift({
+			type: "mdxjsEsm",
+			value: "import { Preview } from 'imprensa/components';",
+			data: { estree: {
+				type: "Program",
+				body: [{
+					type: "ImportDeclaration",
+					specifiers: [{
+						type: "ImportSpecifier",
+						imported: {
+							type: "Identifier",
+							name: "Preview"
+						},
+						local: {
+							type: "Identifier",
+							name: "Preview"
+						}
+					}],
+					source: {
+						type: "Literal",
+						value: "imprensa/components"
+					}
+				}],
+				sourceType: "module"
+			} }
+		});
+	};
+}
+//#endregion
+//#region src/docs/plugin/landing-shiki.ts
+const LANDING_SNIPPETS_FILE = "src/lib/landing-snippets.ts";
+async function loadAppLandingSnippets(root) {
+	const file = path.join(root, LANDING_SNIPPETS_FILE);
+	if (!existsSync(file)) return null;
+	return (await import(pathToFileURL(file).href)).landingSnippets ?? null;
+}
+async function buildLandingShikiModule(root, shiki) {
+	if (shiki === false) return "export {};";
+	const landingSnippets = await loadAppLandingSnippets(root);
+	if (!landingSnippets) return "export {};";
+	const lines = [];
+	for (const [key, { code, lang }] of Object.entries(landingSnippets)) {
+		const html = await codeToSnippetHtml(code, lang, shiki);
+		lines.push(`export const ${key}Html = ${JSON.stringify(html)};`);
+	}
+	return lines.join("\n") || "export {};";
+}
+//#endregion
+//#region src/docs/plugin/virtual-runtime.ts
+/** Re-export surface for the `imprensa` virtual runtime entry (dev ergonomics). */
+const IMPRENSA_VIRTUAL_RUNTIME = `
+export {
+  THEME_STORAGE_KEY,
+  applyInitialTheme,
+  applyThemeToHtml,
+  createImprensa,
+  getStoredTheme,
+  mountOrHydrate,
+  setStoredTheme,
+} from "imprensa/runtime";
+export {
+  LogoButton,
+  SearchOverlay,
+  ThemeToggle,
+} from "imprensa/components";
+export const shiki = import("imprensa/shiki").then((m) => m.shiki);
+export const shikiThemes = __SHIKI_THEMES__;
+export {
+  DocArticle,
+  DocPager,
+  DocToolbar,
+  getAdjacentDocs,
+} from "imprensa/doc";
+export {
+  articleClass,
+  contentTree,
+  getClientPrerenderedMdxHtml,
+  getDocLinks,
+  getMdxContent,
+  getMdxHead,
+  getMdxSourceForRoute,
+  getPrerenderedMdxHtml,
+  headDefaults,
+  mdxRoutes,
+  renderMdx,
+  renderMdxContent,
+  searchDocuments,
+  setPrerenderedMdxHtml,
+} from "imprensa/mdx";
+`;
+//#endregion
+//#region src/docs/plugin/create-plugins.ts
+/** Resolved from published `dist/index.mjs` → `src/...`. */
+const MDX_SOURCE = fileURLToPath(new URL("../src/docs/mdx.ts", import.meta.url));
+const MDX_RUNTIME_CONFIG = fileURLToPath(new URL("../src/docs/mdx/runtime-config.ts", import.meta.url));
+const COMPONENTS_INDEX = fileURLToPath(new URL("../src/components/index.tsx", import.meta.url));
+const DOC_ENTRY = fileURLToPath(new URL("../src/components/doc.tsx", import.meta.url));
+const CONFIG_STUB = fileURLToPath(new URL("../src/docs/config.ts", import.meta.url));
+const ICONS_ENTRY = fileURLToPath(new URL("../src/components/icons.tsx", import.meta.url));
+const IMPRENSA_PRERENDER_ENTRY = path.resolve(fileURLToPath(new URL("./core/prerender-core.mjs", import.meta.url)));
+const IMPRENSA_CLIENT_RUNTIME = path.resolve(fileURLToPath(new URL("./core/client-runtime.mjs", import.meta.url)));
+function isMdxConfigTarget(id) {
+	return id === MDX_RUNTIME_CONFIG || id.endsWith("/imprensa/src/docs/mdx/runtime-config.ts") || id === MDX_SOURCE || id.endsWith("/imprensa/src/docs/mdx.ts");
+}
+function isAppPageFile(file, root) {
+	const relative = path.relative(path.join(root, "src/pages"), file).replace(/\\/g, "/");
+	return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function createImprensaVitePlugins(options = {}) {
+	const { shiki, mdx: mdxOptions = {}, pages: pagesOptions = {}, contentDir = "src/pages/(content)", detectDeadLink = true, llms = true, repo = "", repoBranch = "main", repoPath = "", hostname, head: headDefaults, socials = [], preview = {} } = options;
+	const { rehypePlugins, remarkPlugins, ...restMdxOptions } = mdxOptions;
+	const resolvedRemarkPlugins = remarkPlugins ?? [];
+	const resolvedRehypePlugins = rehypePlugins ?? [];
+	const coreRehypePlugins = [
+		rehypeSlug,
+		[rehypeAutolinkHeadings, {
+			behavior: "wrap",
+			properties: { className: ["heading-anchor"] }
+		}],
+		...detectDeadLink ? [rehypeDeadLinks] : []
+	];
+	const highlighterOptions = getShikiHighlighterOptions(shiki);
+	const shikiThemes = shiki === false || !shiki?.themes ? {
+		light: "night-owl-light",
+		dark: "houston"
+	} : shiki.themes;
+	let isBuild = false;
+	const ilhaPagesOptions = {
+		interceptLinks: false,
+		...pagesOptions,
+		mode: pagesOptions.mode ?? "static"
+	};
+	const plugins = [
+		mdx({
+			jsxImportSource: "ilha",
+			...restMdxOptions,
+			remarkPlugins: [remarkPreview, ...resolvedRemarkPlugins],
+			rehypePlugins: [
+				...shikiPlugin(shiki),
+				...coreRehypePlugins,
+				...resolvedRehypePlugins
+			]
+		}),
+		{
+			name: "imprensa:ilha-pages",
+			enforce: "pre",
+			config(_config, { command }) {
+				ilhaPagesOptions.mode = pagesOptions.mode ?? (command === "serve" ? "spa" : "static");
+			}
+		},
+		pages(ilhaPagesOptions)
+	];
+	plugins.push(tailwindcss());
+	plugins.push(vitePrerenderPlugin({
+		renderTarget: "#app",
+		prerenderScript: path.join(process.cwd(), "src/main.ts")
+	}));
+	plugins.push(sitemap({
+		hostname,
+		dynamicRoutes: collectMdxRoutes(contentDir)
+	}));
+	plugins.push({
+		name: "imprensa:html",
+		transformIndexHtml: {
+			order: "pre",
+			handler(html) {
+				if (!html.includes("imprensa-sidebar-layout-boot")) html = html.replace("</head>", `    ${SIDEBAR_LAYOUT_BOOT_SCRIPT}\n  </head>`);
+				return html;
+			}
+		}
+	});
+	plugins.push({
+		name: "imprensa:html-post",
+		apply: "build",
+		transformIndexHtml: {
+			order: "post",
+			handler(html) {
+				return html.replace(/<link rel="stylesheet" crossorigin href="(\/assets\/[^"]+\.css)">/g, "<link rel=\"preload\" as=\"style\" href=\"$1\" crossorigin />\n    $&");
+			}
+		}
+	});
+	plugins.push({
+		name: "imprensa:config",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === "imprensa") return "\0imprensa:runtime";
+			if (id === "imprensa/shiki") return "\0imprensa:shiki";
+			if (id === "imprensa/config") return "\0imprensa:config";
+			if (id === CONFIG_STUB || id.endsWith("/imprensa/src/docs/config.ts")) return "\0imprensa:config";
+			if (id === "imprensa/mdx") return MDX_SOURCE;
+			if (id === "imprensa/components") return COMPONENTS_INDEX;
+			if (id === "imprensa/doc") return DOC_ENTRY;
+			if (id === "imprensa/icons") return ICONS_ENTRY;
+			if (id === "imprensa/landing-shiki") return "\0imprensa:landing-shiki";
+		},
+		async load(id) {
+			if (id === "\0imprensa:landing-shiki") return buildLandingShikiModule(process.cwd(), shiki);
+			if (id === "\0imprensa:config") return `export const socials = ${JSON.stringify(socials)};
+export const preview = ${JSON.stringify(preview)};
+export const shiki = ${JSON.stringify(shiki === false ? false : shiki ?? {})};
+export const hostname = ${JSON.stringify(hostname ?? "")};
+export const shikiThemes = ${JSON.stringify(shikiThemes)};`;
+			if (id === "\0imprensa:shiki") {
+				if (!highlighterOptions.clientShiki || highlighterOptions.langs.length === 0) return `export const shiki = {
+  loadLanguage: async () => {},
+  codeToHtml: () => "",
+};`;
+				return shikiFineGrainedRuntime({
+					themes: highlighterOptions.themes,
+					langs: highlighterOptions.langs
+				});
+			}
+			if (id !== "\0imprensa:runtime") return;
+			return IMPRENSA_VIRTUAL_RUNTIME.replace("__SHIKI_THEMES__", JSON.stringify(shikiThemes));
+		},
+		transform(code, id) {
+			if (/\.mdx?$/.test(id) && code.startsWith("---")) {
+				const end = code.indexOf("\n---", 3);
+				if (end !== -1) return {
+					code: code.slice(end + 4),
+					map: null
+				};
+			}
+			if (!isMdxConfigTarget(id)) return;
+			return code.replace(MDX_CONFIG_MARKER, `export const contentDir = ${JSON.stringify(normalizeContentDir(contentDir))};
+export const imprensaRepo = ${JSON.stringify(repo)};
+export const imprensaRepoBranch = ${JSON.stringify(repoBranch)};
+export const imprensaRepoPath = ${JSON.stringify(repoPath)};
+export const mdxRawSources = ${JSON.stringify(collectRawMdxSources(process.cwd(), contentDir))} as Record<string, string>;
+export const headDefaults = ${JSON.stringify(headDefaults ?? null)} as import("unhead/types").ResolvableHead | null;`);
+		},
+		handleHotUpdate(ctx) {
+			if (!isAppPageFile(ctx.file, ctx.server.config.root)) return;
+			for (const module of ctx.server.moduleGraph.getModulesByFile(MDX_RUNTIME_CONFIG) ?? []) ctx.server.moduleGraph.invalidateModule(module);
+			for (const module of ctx.server.moduleGraph.getModulesByFile(MDX_SOURCE) ?? []) ctx.server.moduleGraph.invalidateModule(module);
+			ctx.server.ws.send({
+				type: "full-reload",
+				path: "*"
+			});
+			return [];
+		},
+		config() {
+			const root = process.cwd();
+			let sonner = "sonner";
+			try {
+				sonner = createRequire(path.join(root, "package.json")).resolve("sonner");
+			} catch {}
+			return {
+				server: { watch: { usePolling: true } },
+				build: { rolldownOptions: { output: { codeSplitting: { groups: [{
+					name: "imprensa-search",
+					test: /minisearch/
+				}] } } } },
+				resolve: {
+					alias: {
+						$lib: path.resolve(root, "src", "lib"),
+						sonner,
+						"imprensa/prerender": IMPRENSA_PRERENDER_ENTRY,
+						"imprensa/runtime": IMPRENSA_CLIENT_RUNTIME
+					},
+					dedupe: [
+						"@areia/slots",
+						"@ilha/router",
+						"areia",
+						"ilha",
+						"lucide",
+						"minisearch",
+						"quando",
+						"sonner"
+					]
+				}
+			};
+		},
+		configResolved(config) {
+			isBuild = config.command === "build";
+		},
+		closeBundle() {
+			if (!isBuild) return;
+			generateLlmsArtifacts({
+				root: process.cwd(),
+				outDir: path.resolve(process.cwd(), "dist"),
+				contentDir,
+				llms
+			});
+		}
+	});
+	return plugins;
+}
+//#endregion
+//#region src/docs/vite-plugin.ts
+/** Vite meta-plugin preset for Imprensa documentation sites. */
+function imprensa(options = {}) {
+	return createImprensaVitePlugins(options);
+}
+//#endregion
+export { THEME_STORAGE_KEY, applyInitialTheme, applyThemeToHtml, createImprensa, createPrerender, getStoredTheme, imprensa, mountOrHydrate, setStoredTheme, shiki, shikiThemes };