@slidev-react/node 0.1.0

package/dist/exportBrowser.mjs

@@ -0,0 +1,123 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { clampSlideSelection, createRangesFromSlides, createSlideSelectionLabel, expandSlideSelection, toPdfPageRanges } from "@slidev-react/core/presentation/export/selection";
+import { chromium } from "@playwright/test";
+import { createSlideSnapshotFileName, resolveExportSlidesBaseName } from "@slidev-react/core/presentation/export/fileNames";
+//#region src/exportBrowser.ts
+async function readExportViewport(page) {
+	return page.locator("[data-export-view=\"print\"]").evaluate((node) => ({
+		width: Number.parseInt(node.getAttribute("data-export-viewport-width") ?? "1920", 10),
+		height: Number.parseInt(node.getAttribute("data-export-viewport-height") ?? "1080", 10)
+	}));
+}
+async function readSnapshotInfos(page) {
+	return page.locator("[data-export-snapshot=\"slide\"]").evaluateAll((nodes) => nodes.map((node, index) => ({
+		page: index + 1,
+		slideNumber: Number.parseInt(node.getAttribute("data-export-slide") ?? "0", 10),
+		title: node.getAttribute("data-export-slide-title") ?? "",
+		click: node.getAttribute("data-export-click") ?? "all"
+	})));
+}
+function resolveSnapshotSelection(snapshotInfos, slideSelection, withClicks) {
+	const totalSlides = new Set(snapshotInfos.map((info) => info.slideNumber)).size;
+	const selectedRanges = clampSlideSelection(slideSelection, totalSlides);
+	const selectedSlides = expandSlideSelection(selectedRanges);
+	if (selectedSlides.length === 0) throw new Error(`No slides matched --slides for a slides file with ${totalSlides} slides.`);
+	const selectedSlideSet = new Set(selectedSlides);
+	const selectedSnapshots = snapshotInfos.filter((info) => selectedSlideSet.has(info.slideNumber));
+	if (selectedSnapshots.length === 0) throw new Error("No export snapshots matched the requested slides.");
+	return {
+		selectedSlides,
+		selectedSnapshots,
+		variantLabel: [selectedRanges.length === 1 && selectedRanges[0].start === 1 && selectedRanges[0].end === totalSlides ? null : createSlideSelectionLabel(selectedRanges), withClicks ? "with-clicks" : null].filter(Boolean).join("-")
+	};
+}
+async function exportPdfArtifacts(page, exportViewport, slidesBaseName, slidesOutputDir, variantLabel, selectedSnapshots) {
+	const pdfPath = path.join(slidesOutputDir, variantLabel ? `${slidesBaseName}-${variantLabel}.pdf` : `${slidesBaseName}.pdf`);
+	await page.emulateMedia({ media: "print" });
+	await page.pdf({
+		path: pdfPath,
+		landscape: exportViewport.width > exportViewport.height,
+		printBackground: true,
+		preferCSSPageSize: true,
+		pageRanges: toPdfPageRanges(createRangesFromSlides(selectedSnapshots.map((info) => info.page)))
+	});
+	await page.emulateMedia({ media: "screen" });
+	return pdfPath;
+}
+async function applyPngExportStyles(page, exportViewport) {
+	await page.addStyleTag({ content: `
+      .print-slides-view main {
+        max-width: none !important;
+      }
+      .print-slide-shell {
+        width: ${exportViewport.width}px !important;
+        margin-left: auto !important;
+        margin-right: auto !important;
+      }
+      .print-slide-frame {
+        padding: 0 !important;
+        border: none !important;
+        background: transparent !important;
+        box-shadow: none !important;
+      }
+      .print-slide-frame [data-export-surface="slide"] {
+        width: ${exportViewport.width}px !important;
+        height: ${exportViewport.height}px !important;
+        max-width: none !important;
+        min-height: ${exportViewport.height}px !important;
+        aspect-ratio: auto !important;
+        box-shadow: none !important;
+      }
+    ` });
+}
+async function exportPngArtifacts(page, exportViewport, pngOutputDir, withClicks, selectedSnapshots) {
+	await mkdir(pngOutputDir, { recursive: true });
+	await applyPngExportStyles(page, exportViewport);
+	const createdFiles = [];
+	for (const snapshot of selectedSnapshots) {
+		const shell = page.locator(`[data-export-snapshot="slide"][data-export-slide="${snapshot.slideNumber}"][data-export-click="${snapshot.click}"]`).first();
+		const fileName = createSlideSnapshotFileName({
+			index: snapshot.slideNumber,
+			title: snapshot.title,
+			clickStep: withClicks && snapshot.click !== "all" ? Number.parseInt(snapshot.click, 10) : null
+		});
+		const targetPath = path.join(pngOutputDir, fileName);
+		await shell.locator("[data-export-surface=\"slide\"]").screenshot({ path: targetPath });
+		createdFiles.push(targetPath);
+	}
+	return createdFiles;
+}
+async function exportSlidesInBrowser(options) {
+	const browser = await chromium.launch({ headless: true });
+	try {
+		const page = await browser.newPage({
+			viewport: {
+				width: 2400,
+				height: 1600
+			},
+			deviceScaleFactor: 1
+		});
+		await page.goto(options.printUrl, { waitUntil: "networkidle" });
+		await page.waitForSelector("[data-export-view=\"print\"]");
+		await page.waitForFunction(() => Array.from(document.querySelectorAll("[data-export-slide-ready=\"false\"]")).length === 0);
+		const exportViewport = await readExportViewport(page);
+		const slidesBaseName = resolveExportSlidesBaseName(await page.title());
+		const { selectedSlides, selectedSnapshots, variantLabel } = resolveSnapshotSelection(await readSnapshotInfos(page), options.slideSelection, options.withClicks);
+		const slidesOutputDir = path.resolve(options.outputDir, slidesBaseName);
+		const pngOutputDir = variantLabel ? path.join(slidesOutputDir, "png", variantLabel) : path.join(slidesOutputDir, "png");
+		await mkdir(slidesOutputDir, { recursive: true });
+		const createdFiles = [];
+		if (options.format === "all" || options.format === "pdf") createdFiles.push(await exportPdfArtifacts(page, exportViewport, slidesBaseName, slidesOutputDir, variantLabel, selectedSnapshots));
+		if (options.format === "all" || options.format === "png") createdFiles.push(...await exportPngArtifacts(page, exportViewport, pngOutputDir, options.withClicks, selectedSnapshots));
+		return {
+			createdFiles,
+			selectedSlides,
+			variantLabel
+		};
+	} finally {
+		await browser.close();
+	}
+}
+//#endregion
+export { exportSlidesInBrowser };

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { buildSlidesApp, runSlidesBuild } from "./build.mjs";
+import { exportSlidesArtifacts, runSlidesExport } from "./export.mjs";
+import { runSlidesDev, startSlidesDevServer, stopSlidesDevServer } from "./dev.mjs";
+import { lintSlides, runSlidesLint } from "./lint.mjs";
+export { buildSlidesApp, exportSlidesArtifacts, lintSlides, runSlidesBuild, runSlidesDev, runSlidesExport, runSlidesLint, startSlidesDevServer, stopSlidesDevServer };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { buildSlidesApp, runSlidesBuild } from "./build.mjs";
+import { runSlidesDev, startSlidesDevServer, stopSlidesDevServer } from "./dev.mjs";
+import { exportSlidesArtifacts, runSlidesExport } from "./export.mjs";
+import { lintSlides, runSlidesLint } from "./lint.mjs";
+export { buildSlidesApp, exportSlidesArtifacts, lintSlides, runSlidesBuild, runSlidesDev, runSlidesExport, runSlidesLint, startSlidesDevServer, stopSlidesDevServer };

package/dist/lint.d.mts

@@ -0,0 +1,15 @@
+import { CommandResult, SlidesCommandOptions } from "./context.mjs";
+
+//#region src/lint.d.ts
+interface LintSlidesOptions extends SlidesCommandOptions {
+  cliArgs?: string[];
+}
+interface LintSlidesResult {
+  strict: boolean;
+  warnings: string[];
+  slidesSourceFile: string;
+}
+declare function lintSlides(options?: LintSlidesOptions): Promise<LintSlidesResult>;
+declare function runSlidesLint(options?: LintSlidesOptions): Promise<CommandResult>;
+//#endregion
+export { lintSlides, runSlidesLint };

package/dist/lint.mjs

@@ -0,0 +1,36 @@
+import { createFailureResult, createSuccessResult, resolveSlidesCommandContext } from "./context.mjs";
+import { parseSlides } from "./slides/parsing/parseSlides.mjs";
+import { validateSlidesAuthoring } from "./slides/validation/validateSlidesAuthoring.mjs";
+import { parseLintArgs } from "./cli/lintArgs.mjs";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/lint.ts
+async function lintSlides(options = {}) {
+	const parsedArgs = parseLintArgs(options.cliArgs ?? []);
+	const context = resolveSlidesCommandContext({
+		...options,
+		slidesFile: options.slidesFile ?? parsedArgs.slidesFile
+	});
+	const slides = parseSlides(await readFile(context.slidesSourceFile, "utf8"));
+	const warnings = await validateSlidesAuthoring({
+		appRoot: context.appRoot,
+		slides
+	});
+	return {
+		strict: parsedArgs.strict,
+		warnings,
+		slidesSourceFile: context.slidesSourceFile
+	};
+}
+async function runSlidesLint(options = {}) {
+	const result = await lintSlides(options);
+	if (result.warnings.length === 0) {
+		console.log(`Slides lint passed: no authoring warnings for ${path.relative(process.cwd(), result.slidesSourceFile)}`);
+		return createSuccessResult();
+	}
+	console.warn(`Slides lint found ${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"}:`);
+	for (const warning of result.warnings) console.warn(`- ${warning}`);
+	return result.strict ? createFailureResult(1) : createSuccessResult();
+}
+//#endregion
+export { lintSlides, runSlidesLint };

package/dist/slides/build/createSlidesViteConfig.d.mts

@@ -0,0 +1,9 @@
+import { UserConfig } from "vite";
+
+//#region src/slides/build/createSlidesViteConfig.d.ts
+declare function createSlidesViteConfig(options: {
+  appRoot: string;
+  slidesFile?: string;
+}): UserConfig;
+//#endregion
+export { createSlidesViteConfig };

package/dist/slides/build/createSlidesViteConfig.mjs

@@ -0,0 +1,25 @@
+import { resolveSlidesSourceFile } from "./slidesSourceFile.mjs";
+import { generatedSlidesAlias, generatedSlidesEntry, pluginCompileTimeSlides } from "./generateCompiledSlides.mjs";
+import path from "node:path";
+import react from "@vitejs/plugin-react";
+//#region src/slides/build/createSlidesViteConfig.ts
+function createSlidesViteConfig(options) {
+	const { appRoot, slidesFile } = options;
+	return {
+		root: appRoot,
+		plugins: [pluginCompileTimeSlides({
+			appRoot,
+			slidesSourceFile: resolveSlidesSourceFile(appRoot, slidesFile)
+		}), react()],
+		resolve: { alias: {
+			"@": path.resolve(appRoot, "./packages/client/src"),
+			[generatedSlidesAlias]: path.resolve(appRoot, generatedSlidesEntry),
+			react: path.resolve(appRoot, "./node_modules/react"),
+			"react-dom": path.resolve(appRoot, "./node_modules/react-dom"),
+			"react/jsx-runtime": path.resolve(appRoot, "./node_modules/react/jsx-runtime.js"),
+			"react/jsx-dev-runtime": path.resolve(appRoot, "./node_modules/react/jsx-dev-runtime.js")
+		} }
+	};
+}
+//#endregion
+export { createSlidesViteConfig };

package/dist/slides/build/generateCompiledSlides.mjs

@@ -0,0 +1,264 @@
+import { getMdxCompileOptions } from "../compiling/mdx-options.mjs";
+import { parseImportedSlides, parseSlides } from "../parsing/parseSlides.mjs";
+import { validateSlidesAuthoring } from "../validation/validateSlidesAuthoring.mjs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { compile } from "@mdx-js/mdx";
+//#region src/slides/build/generateCompiledSlides.ts
+const GENERATED_SLIDES_DIR_ROOT = ".generated/slides";
+const GENERATED_SLIDE_MODULES_DIR = `${GENERATED_SLIDES_DIR_ROOT}/slides`;
+const GENERATED_MANIFEST_FILE = `${GENERATED_SLIDES_DIR_ROOT}/index.ts`;
+function hashString(source) {
+	return createHash("sha256").update(source).digest("hex").slice(0, 12);
+}
+function toModuleIdentifier(slideId) {
+	return slideId.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function createSlideModuleFileName(index) {
+	return `slide-${index + 1}.tsx`;
+}
+function createSlideModuleCode(compiledSource) {
+	return [
+		"/* eslint-disable */",
+		"/* @generated by compile-time slides pipeline */",
+		compiledSource.trim(),
+		""
+	].join("\n");
+}
+function normalizeDiagramCodeProps(compiledSource) {
+	return compiledSource.replace(/<(MermaidDiagram|PlantUmlDiagram) code="([\s\S]*?)" \/>/g, (_match, componentName, code) => `<${componentName} code={${JSON.stringify(code)}} />`);
+}
+function createManifestCode({ deckSourceHash, deckMeta, slideEntries }) {
+	const imports = slideEntries.map((entry) => `import ${entry.importName} from '${entry.importPath}'`).join("\n");
+	const slides = slideEntries.map((entry) => `    {
+      id: ${JSON.stringify(entry.id)},
+      meta: ${JSON.stringify(entry.meta, null, 6)},
+      component: ${entry.importName},
+    }`).join(",\n");
+	return [
+		"/* eslint-disable */",
+		"/* @generated by compile-time slides pipeline */",
+		"import type { CompiledSlidesManifest } from '@slidev-react/core/slides/compiled-slides'",
+		imports,
+		"",
+		"const compiledSlides: CompiledSlidesManifest = {",
+		`  sourceHash: ${JSON.stringify(deckSourceHash)},`,
+		`  meta: ${JSON.stringify(deckMeta, null, 2)},`,
+		"  slides: [",
+		slides,
+		"  ],",
+		"}",
+		"",
+		"export default compiledSlides",
+		""
+	].join("\n");
+}
+async function writeIfChanged(filePath, content) {
+	try {
+		if (await readFile(filePath, "utf8") === content) return;
+	} catch {}
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, content, "utf8");
+}
+async function removeStaleGeneratedSlides(slidesDir, expectedFiles) {
+	try {
+		const files = await readdir(slidesDir);
+		await Promise.all(files.map(async (fileName) => {
+			if (!expectedFiles.has(fileName)) await unlink(path.join(slidesDir, fileName));
+		}));
+	} catch {}
+}
+async function compileSlideModule(source) {
+	const compiled = await compile(source, {
+		...getMdxCompileOptions(),
+		development: false,
+		jsx: true,
+		jsxImportSource: "react",
+		providerImportSource: "@mdx-js/react"
+	});
+	return normalizeDiagramCodeProps(String(compiled));
+}
+function createSlidesSourceHash({ slidesSource, resolvedSlides }) {
+	return hashString(JSON.stringify({
+		slidesSource,
+		slides: resolvedSlides.map((slide) => ({
+			id: slide.id,
+			source: slide.source,
+			externalFilePath: slide.externalFilePath,
+			externalFileSource: slide.externalFileSource
+		}))
+	}));
+}
+async function resolveSlideUnitSource({ slide, slidesSourceFile }) {
+	const slideSrc = slide.meta.src?.trim();
+	if (!slideSrc) return [{
+		...slide,
+		watchedFiles: [],
+		externalFilePath: void 0,
+		externalFileSource: void 0
+	}];
+	if (slide.hasInlineSource) throw new Error(`Slide ${slide.index + 1}${slide.meta.title ? ` (${slide.meta.title})` : ""} mixes inline content with src. Use one or the other.`);
+	const externalFilePath = path.resolve(path.dirname(slidesSourceFile), slideSrc);
+	let externalFileSource;
+	try {
+		externalFileSource = await readFile(externalFilePath, "utf8");
+	} catch (error) {
+		throw new Error(`Failed to load slide ${slide.index + 1}${slide.meta.title ? ` (${slide.meta.title})` : ""} src "${slideSrc}": ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	const importedSlides = parseImportedSlides(externalFileSource);
+	for (const importedSlide of importedSlides) {
+		if (!importedSlide.meta.src) continue;
+		throw new Error(`Nested src is not supported in slide ${slide.index + 1}${slide.meta.title ? ` (${slide.meta.title})` : ""}.`);
+	}
+	return importedSlides.map((importedSlide) => ({
+		...importedSlide,
+		meta: {
+			...importedSlide.meta,
+			...slide.meta
+		},
+		watchedFiles: [externalFilePath],
+		externalFilePath,
+		externalFileSource
+	}));
+}
+async function generateCompiledSlidesArtifacts(options) {
+	const { appRoot, slidesSourceFile } = options;
+	const slidesSource = await readFile(slidesSourceFile, "utf8");
+	const parsedSlides = parseSlides(slidesSource);
+	const generatedSlidesRootDir = path.join(appRoot, GENERATED_SLIDES_DIR_ROOT);
+	const generatedSlideModulesDir = path.join(appRoot, GENERATED_SLIDE_MODULES_DIR);
+	const manifestFile = path.join(appRoot, GENERATED_MANIFEST_FILE);
+	const expectedSlideFiles = /* @__PURE__ */ new Set();
+	const watchedFiles = new Set([slidesSourceFile]);
+	const manifestEntries = [];
+	const resolvedSlides = (await Promise.all(parsedSlides.slides.map((slide) => resolveSlideUnitSource({
+		slide,
+		slidesSourceFile
+	})))).flat().map((slide, index) => ({
+		...slide,
+		id: `slide-${index + 1}`,
+		index
+	}));
+	const warnings = await validateSlidesAuthoring({
+		appRoot,
+		slides: {
+			meta: parsedSlides.meta,
+			slides: resolvedSlides
+		}
+	});
+	const sourceHash = createSlidesSourceHash({
+		slidesSource,
+		resolvedSlides
+	});
+	await mkdir(generatedSlideModulesDir, { recursive: true });
+	for (const slide of resolvedSlides) {
+		const slideFileName = createSlideModuleFileName(slide.index);
+		const slideFilePath = path.join(generatedSlideModulesDir, slideFileName);
+		const importName = toModuleIdentifier(slide.id);
+		for (const watchedFile of slide.watchedFiles) watchedFiles.add(watchedFile);
+		try {
+			await writeIfChanged(slideFilePath, createSlideModuleCode(await compileSlideModule(slide.source)));
+		} catch (error) {
+			const slideName = slide.meta.title ? `${slide.index + 1} (${slide.meta.title})` : String(slide.index + 1);
+			throw new Error(`Failed to compile slide ${slideName}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		expectedSlideFiles.add(slideFileName);
+		manifestEntries.push({
+			id: slide.id,
+			importName,
+			importPath: `./slides/${path.basename(slideFileName, path.extname(slideFileName))}`,
+			meta: slide.meta
+		});
+	}
+	await removeStaleGeneratedSlides(generatedSlideModulesDir, expectedSlideFiles);
+	await writeIfChanged(manifestFile, createManifestCode({
+		deckSourceHash: sourceHash,
+		deckMeta: parsedSlides.meta,
+		slideEntries: manifestEntries
+	}));
+	return {
+		generatedSlidesRootDir,
+		manifestFile,
+		sourceHash,
+		watchedFiles: [...watchedFiles],
+		warnings
+	};
+}
+function createSlidesGenerator(options) {
+	let generatePromise = null;
+	let rerunRequested = false;
+	let watchedFiles = new Set([options.slidesSourceFile]);
+	let warnings = [];
+	const generate = async () => {
+		if (generatePromise) {
+			rerunRequested = true;
+			await generatePromise;
+			return;
+		}
+		generatePromise = (async () => {
+			do {
+				rerunRequested = false;
+				const result = await generateCompiledSlidesArtifacts(options);
+				watchedFiles = new Set(result.watchedFiles);
+				warnings = result.warnings;
+			} while (rerunRequested);
+		})();
+		try {
+			await generatePromise;
+		} finally {
+			generatePromise = null;
+		}
+	};
+	return {
+		generate,
+		getWatchedFiles: () => [...watchedFiles],
+		getWarnings: () => warnings
+	};
+}
+async function regenerateSlidesForServer(server, generate) {
+	try {
+		await generate();
+		server.ws.send({ type: "full-reload" });
+	} catch (error) {
+		server.config.logger.error(error instanceof Error ? error.stack ?? error.message : String(error), { timestamp: true });
+	}
+}
+function pluginCompileTimeSlides(options) {
+	const slidesSourceFile = path.resolve(options.slidesSourceFile);
+	const generator = createSlidesGenerator({
+		...options,
+		slidesSourceFile
+	});
+	return {
+		name: "slide-react-compile-time-slides",
+		async buildStart() {
+			await generator.generate();
+			for (const warning of generator.getWarnings()) this.warn(warning);
+			for (const watchedFile of generator.getWatchedFiles()) this.addWatchFile(watchedFile);
+		},
+		configureServer(server) {
+			server.watcher.add(slidesSourceFile);
+			const syncWatchedFiles = () => {
+				server.watcher.add(generator.getWatchedFiles());
+			};
+			const handleSlidesChange = async (filePath) => {
+				const resolvedFilePath = path.resolve(filePath);
+				if (!generator.getWatchedFiles().includes(resolvedFilePath)) return;
+				await regenerateSlidesForServer(server, async () => {
+					await generator.generate();
+					for (const warning of generator.getWarnings()) server.config.logger.warn(warning, { timestamp: true });
+					syncWatchedFiles();
+				});
+			};
+			syncWatchedFiles();
+			server.watcher.on("add", handleSlidesChange);
+			server.watcher.on("change", handleSlidesChange);
+			server.watcher.on("unlink", handleSlidesChange);
+		}
+	};
+}
+const generatedSlidesAlias = "@generated/slides";
+const generatedSlidesEntry = path.join(GENERATED_SLIDES_DIR_ROOT, "index.ts");
+//#endregion
+export { generatedSlidesAlias, generatedSlidesEntry, pluginCompileTimeSlides };

package/dist/slides/build/slidesSourceFile.mjs

@@ -0,0 +1,9 @@
+import path from "node:path";
+//#region src/slides/build/slidesSourceFile.ts
+const DEFAULT_SLIDES_SOURCE_FILE = "slides.mdx";
+function resolveSlidesSourceFile(appRoot, slidesFile) {
+	const configuredSlidesFile = slidesFile?.trim() || process.env.SLIDES_FILE?.trim() || DEFAULT_SLIDES_SOURCE_FILE;
+	return path.resolve(appRoot, configuredSlidesFile);
+}
+//#endregion
+export { resolveSlidesSourceFile };

package/dist/slides/compiling/mdx-options.mjs

@@ -0,0 +1,18 @@
+import { remarkDiagramComponents } from "../mdx/remarkDiagramComponents.mjs";
+import { rehypeShikiVitesse } from "./rehypeShikiVitesse.mjs";
+import rehypeKatex from "rehype-katex";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+//#region src/slides/compiling/mdx-options.ts
+function getMdxCompileOptions() {
+	return {
+		remarkPlugins: [
+			remarkGfm,
+			remarkMath,
+			remarkDiagramComponents
+		],
+		rehypePlugins: [rehypeKatex, rehypeShikiVitesse]
+	};
+}
+//#endregion
+export { getMdxCompileOptions };

package/dist/slides/compiling/rehypeShikiVitesse.mjs

@@ -0,0 +1,93 @@
+import { createHighlighter } from "shiki";
+//#region src/slides/compiling/rehypeShikiVitesse.ts
+const SHIKI_THEME = "vitesse-light";
+const PLAIN_TEXT_LANG = "txt";
+const preloadedLangs = [
+	"md",
+	"markdown",
+	"js",
+	"jsx",
+	"ts",
+	"tsx",
+	"json",
+	"bash",
+	"sh",
+	"yaml",
+	"yml",
+	"html",
+	"css",
+	"vue",
+	"txt"
+];
+let highlighterPromise = null;
+function getHighlighter() {
+	if (!highlighterPromise) highlighterPromise = createHighlighter({
+		themes: [SHIKI_THEME],
+		langs: preloadedLangs
+	});
+	return highlighterPromise;
+}
+function asArray(value) {
+	if (!value) return [];
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof item === "string") return item;
+		try {
+			return JSON.stringify(item) ?? "";
+		} catch {
+			return "";
+		}
+	});
+	if (typeof value === "string") return [value];
+	try {
+		return [JSON.stringify(value) ?? ""];
+	} catch {
+		return [];
+	}
+}
+function isElement(node, tagName) {
+	return node?.type === "element" && (!tagName || node.tagName === tagName);
+}
+function extractText(node) {
+	if (!node) return "";
+	if (node.type === "text") return node.value ?? "";
+	if (!node.children) return "";
+	return node.children.map((child) => extractText(child)).join("");
+}
+function detectLanguage(preNode) {
+	const codeNode = preNode.children?.find((child) => isElement(child, "code")) ?? null;
+	if (!codeNode) return PLAIN_TEXT_LANG;
+	const languageClass = asArray(codeNode.properties?.className).find((name) => name.startsWith("language-"));
+	if (!languageClass) return PLAIN_TEXT_LANG;
+	return languageClass.slice(9).trim() || PLAIN_TEXT_LANG;
+}
+async function highlight(code, lang) {
+	const highlighter = await getHighlighter();
+	try {
+		return highlighter.codeToHast(code, {
+			lang,
+			theme: SHIKI_THEME
+		});
+	} catch {
+		return highlighter.codeToHast(code, {
+			lang: PLAIN_TEXT_LANG,
+			theme: SHIKI_THEME
+		});
+	}
+}
+async function walk(node, parent, index) {
+	if (isElement(node, "pre") && parent && index !== null) {
+		const rendered = await highlight(extractText(node), detectLanguage(node));
+		const replacement = rendered?.type === "root" ? rendered.children?.[0] : rendered;
+		if (replacement && parent.children) parent.children[index] = replacement;
+		return;
+	}
+	if (!node.children) return;
+	for (let childIndex = 0; childIndex < node.children.length; childIndex += 1) await walk(node.children[childIndex], node, childIndex);
+}
+function rehypeShikiVitesse() {
+	return async (tree) => {
+		await walk(tree, null, null);
+	};
+}
+//#endregion
+export { rehypeShikiVitesse };

package/dist/slides/mdx/remarkDiagramComponents.mjs

@@ -0,0 +1,38 @@
+//#region src/slides/mdx/remarkDiagramComponents.ts
+function createDiagramNode(name, code) {
+	return {
+		type: "mdxJsxFlowElement",
+		name,
+		attributes: [],
+		children: [{
+			type: "text",
+			value: code
+		}]
+	};
+}
+function walk(parent) {
+	const children = parent?.children;
+	if (!Array.isArray(children)) return;
+	for (let index = 0; index < children.length; index += 1) {
+		const node = children[index];
+		if (node?.type === "code") {
+			const lang = String(node.lang || "").trim().toLowerCase();
+			if (lang === "mermaid") {
+				children[index] = createDiagramNode("MermaidDiagram", node.value || "");
+				continue;
+			}
+			if (lang === "plantuml" || lang === "startuml") {
+				children[index] = createDiagramNode("PlantUmlDiagram", node.value || "");
+				continue;
+			}
+		}
+		walk(node);
+	}
+}
+function remarkDiagramComponents() {
+	return (tree) => {
+		walk(tree);
+	};
+}
+//#endregion
+export { remarkDiagramComponents };

package/dist/slides/parsing/frontmatter.mjs

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import YAML from "yaml";
+//#region src/slides/parsing/frontmatter.ts
+const OPEN = "---";
+const frontmatterDataSchema = z.object({}).catchall(z.unknown());
+function parseFrontmatter(source) {
+	const normalized = source.replace(/\r\n/g, "\n");
+	if (!normalized.startsWith(`${OPEN}\n`)) return {
+		data: {},
+		content: normalized
+	};
+	const closeMarkerWithNewline = `\n${OPEN}\n`;
+	const closeMarkerAtEnd = `\n${OPEN}`;
+	const withNewlineIndex = normalized.indexOf(closeMarkerWithNewline, 4);
+	const atEndIndex = withNewlineIndex < 0 && normalized.endsWith(closeMarkerAtEnd) ? normalized.length - closeMarkerAtEnd.length : -1;
+	const endIndex = withNewlineIndex >= 0 ? withNewlineIndex : atEndIndex;
+	if (endIndex < 0) throw new Error("Invalid frontmatter: missing closing ---");
+	const yamlSource = normalized.slice(4, endIndex);
+	const raw = YAML.parse(yamlSource);
+	const parsed = frontmatterDataSchema.safeParse(raw ?? {});
+	if (!parsed.success) throw new Error("Invalid frontmatter: expected an object");
+	const contentStart = endIndex + (withNewlineIndex >= 0 ? closeMarkerWithNewline.length : closeMarkerAtEnd.length);
+	return {
+		data: parsed.data,
+		content: normalized.slice(contentStart)
+	};
+}
+//#endregion
+export { parseFrontmatter };