@slidev/cli 51.6.0 → 51.7.0

package/dist/export-D1Zqc-n1.js

@@ -0,0 +1,433 @@
+import { getRoots } from "./resolver-BShaA6qw.js";
+import fs from "node:fs/promises";
+import path, { dirname, relative } from "node:path";
+import process from "node:process";
+import { blue, cyan, dim, green, yellow } from "ansis";
+import { clearUndefined, ensureSuffix, slash } from "@antfu/utils";
+import { resolve as resolve$1 } from "mlly";
+import { Buffer } from "node:buffer";
+import { outlinePdfFactory } from "@lillallol/outline-pdf";
+import { parseRangeString } from "@slidev/parser/core";
+import { Presets, SingleBar } from "cli-progress";
+import * as pdfLib from "pdf-lib";
+import { PDFDocument } from "pdf-lib";
+
+//#region node/commands/export.ts
+function addToTree(tree, info, slideIndexes, level = 1) {
+	const titleLevel = info.level;
+	if (titleLevel && titleLevel > level && tree.length > 0 && tree[tree.length - 1].titleLevel < titleLevel) addToTree(tree[tree.length - 1].children, info, slideIndexes, level + 1);
+	else tree.push({
+		no: info.index,
+		children: [],
+		level,
+		titleLevel: titleLevel ?? level,
+		path: String(slideIndexes[info.index + 1]),
+		hideInToc: Boolean(info.frontmatter?.hideInToc),
+		title: info.title
+	});
+}
+function makeOutline(tree) {
+	return tree.map(({ title, path: path$1, level, children }) => {
+		const rootOutline = title ? `${path$1}|${"-".repeat(level - 1)}|${title}` : null;
+		const childrenOutline = makeOutline(children);
+		return childrenOutline.length > 0 ? `${rootOutline}\n${childrenOutline}` : rootOutline;
+	}).filter((outline) => !!outline).join("\n");
+}
+function createSlidevProgress(indeterminate = false) {
+	function getSpinner(n = 0) {
+		return [
+			cyan("●"),
+			green("◆"),
+			blue("■"),
+			yellow("▲")
+		][n % 4];
+	}
+	let current = 0;
+	let spinner = 0;
+	let timer;
+	const progress = new SingleBar({
+		clearOnComplete: true,
+		hideCursor: true,
+		format: `  {spin} ${yellow("rendering")}${indeterminate ? dim(yellow("...")) : " {bar} {value}/{total}"}`,
+		linewrap: false,
+		barsize: 30
+	}, Presets.shades_grey);
+	return {
+		bar: progress,
+		start(total) {
+			progress.start(total, 0, { spin: getSpinner(spinner) });
+			timer = setInterval(() => {
+				spinner += 1;
+				progress.update(current, { spin: getSpinner(spinner) });
+			}, 200);
+		},
+		update(v) {
+			current = v;
+			progress.update(v, { spin: getSpinner(spinner) });
+		},
+		stop() {
+			clearInterval(timer);
+			progress.stop();
+		}
+	};
+}
+async function exportNotes({ port = 18724, base = "/", output = "notes", timeout = 3e4, wait = 0 }) {
+	const { chromium } = await importPlaywright();
+	const browser = await chromium.launch();
+	const context = await browser.newContext();
+	const page = await context.newPage();
+	const progress = createSlidevProgress(true);
+	progress.start(1);
+	if (!output.endsWith(".pdf")) output = `${output}.pdf`;
+	await page.goto(`http://localhost:${port}${base}presenter/print`, {
+		waitUntil: "networkidle",
+		timeout
+	});
+	await page.waitForLoadState("networkidle");
+	await page.emulateMedia({ media: "screen" });
+	if (wait) await page.waitForTimeout(wait);
+	await page.pdf({
+		path: output,
+		margin: {
+			left: 0,
+			top: 0,
+			right: 0,
+			bottom: 0
+		},
+		printBackground: true,
+		preferCSSPageSize: true
+	});
+	progress.stop();
+	browser.close();
+	return output;
+}
+async function exportSlides({ port = 18724, total = 0, range: range$1, format = "pdf", output = "slides", slides, base = "/", timeout = 3e4, wait = 0, dark = false, routerMode = "history", width = 1920, height = 1080, withClicks = false, executablePath = void 0, withToc = false, perSlide = false, scale = 1, waitUntil, omitBackground = false }) {
+	const pages = parseRangeString(total, range$1);
+	const { chromium } = await importPlaywright();
+	const browser = await chromium.launch({ executablePath });
+	const context = await browser.newContext({
+		viewport: {
+			width,
+			height: perSlide ? height : height * pages.length
+		},
+		deviceScaleFactor: scale
+	});
+	const page = await context.newPage();
+	const progress = createSlidevProgress(!perSlide);
+	progress.start(pages.length);
+	if (format === "pdf") await genPagePdf();
+	else if (format === "png") await genPagePng(output);
+	else if (format === "md") await genPageMd();
+	else if (format === "pptx") {
+		const buffers = await genPagePng(false);
+		await genPagePptx(buffers);
+	} else throw new Error(`[slidev] Unsupported exporting format "${format}"`);
+	progress.stop();
+	browser.close();
+	const relativeOutput = slash(relative(".", output));
+	return relativeOutput.startsWith(".") ? relativeOutput : `./${relativeOutput}`;
+	async function go(no, clicks) {
+		const query = new URLSearchParams();
+		if (withClicks) query.set("print", "clicks");
+		else query.set("print", "true");
+		if (range$1) query.set("range", range$1);
+		if (clicks) query.set("clicks", clicks);
+		const url = routerMode === "hash" ? `http://localhost:${port}${base}?${query}#${no}` : `http://localhost:${port}${base}${no}?${query}`;
+		await page.goto(url, {
+			waitUntil,
+			timeout
+		});
+		if (waitUntil) await page.waitForLoadState(waitUntil);
+		await page.emulateMedia({
+			colorScheme: dark ? "dark" : "light",
+			media: "screen"
+		});
+		const slide = no === "print" ? page.locator("body") : page.locator(`[data-slidev-no="${no}"]`);
+		await slide.waitFor();
+		{
+			const elements = slide.locator(".slidev-slide-loading");
+			const count = await elements.count();
+			for (let index = 0; index < count; index++) await elements.nth(index).waitFor({ state: "detached" });
+		}
+		{
+			const elements = slide.locator("[data-waitfor]");
+			const count = await elements.count();
+			for (let index = 0; index < count; index++) {
+				const element = elements.nth(index);
+				const attribute = await element.getAttribute("data-waitfor");
+				if (attribute) await element.locator(attribute).waitFor({ state: "visible" }).catch((e) => {
+					console.error(e);
+					process.exitCode = 1;
+				});
+			}
+		}
+		{
+			const frames = page.frames();
+			await Promise.all(frames.map((frame) => frame.waitForLoadState()));
+		}
+		{
+			const container = slide.locator("#mermaid-rendering-container");
+			const count = await container.count();
+			if (count > 0) {
+				while (true) {
+					const element = container.locator("div").first();
+					if (await element.count() === 0) break;
+					await element.waitFor({ state: "detached" });
+				}
+				await container.evaluate((node) => node.style.display = "none");
+			}
+		}
+		{
+			const elements = slide.locator(".monaco-aria-container");
+			const count = await elements.count();
+			for (let index = 0; index < count; index++) {
+				const element = elements.nth(index);
+				await element.evaluate((node) => node.style.display = "none");
+			}
+		}
+		if (wait) await page.waitForTimeout(wait);
+	}
+	async function getSlidesIndex() {
+		const clicksBySlide = {};
+		const slides$1 = page.locator(".print-slide-container");
+		const count = await slides$1.count();
+		for (let i = 0; i < count; i++) {
+			const id = await slides$1.nth(i).getAttribute("id") || "";
+			const path$1 = Number(id.split("-")[0]);
+			clicksBySlide[path$1] = (clicksBySlide[path$1] || 0) + 1;
+		}
+		const slideIndexes = Object.fromEntries(Object.entries(clicksBySlide).reduce((acc, [path$1, clicks], i) => {
+			acc.push([path$1, clicks + (acc[i - 1]?.[1] ?? 0)]);
+			return acc;
+		}, []));
+		return slideIndexes;
+	}
+	function getClicksFromUrl(url) {
+		return url.match(/clicks=([1-9]\d*)/)?.[1];
+	}
+	async function genPageWithClicks(fn, no, clicks) {
+		await fn(no, clicks);
+		if (withClicks) {
+			await page.keyboard.press("ArrowRight", { delay: 100 });
+			const _clicks = getClicksFromUrl(page.url());
+			if (_clicks && clicks !== _clicks) await genPageWithClicks(fn, no, _clicks);
+		}
+	}
+	async function genPagePdfPerSlide() {
+		const buffers = [];
+		const genPdfBuffer = async (i, clicks) => {
+			await go(i, clicks);
+			const pdf = await page.pdf({
+				width,
+				height,
+				margin: {
+					left: 0,
+					top: 0,
+					right: 0,
+					bottom: 0
+				},
+				pageRanges: "1",
+				printBackground: true,
+				preferCSSPageSize: true
+			});
+			buffers.push(pdf);
+		};
+		let idx = 0;
+		for (const i of pages) {
+			await genPageWithClicks(genPdfBuffer, i);
+			progress.update(++idx);
+		}
+		let mergedPdf = await PDFDocument.create({});
+		for (const pdfBytes of buffers) {
+			const pdf = await PDFDocument.load(pdfBytes);
+			const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+			copiedPages.forEach((page$1) => {
+				mergedPdf.addPage(page$1);
+			});
+		}
+		addPdfMetadata(mergedPdf);
+		if (withToc) mergedPdf = await addTocToPdf(mergedPdf);
+		const buffer = await mergedPdf.save();
+		await fs.writeFile(output, buffer);
+	}
+	async function genPagePdfOnePiece() {
+		await go("print");
+		await page.pdf({
+			path: output,
+			width,
+			height,
+			margin: {
+				left: 0,
+				top: 0,
+				right: 0,
+				bottom: 0
+			},
+			printBackground: true,
+			preferCSSPageSize: true
+		});
+		let pdfData = await fs.readFile(output);
+		let pdf = await PDFDocument.load(pdfData);
+		addPdfMetadata(pdf);
+		if (withToc) pdf = await addTocToPdf(pdf);
+		pdfData = Buffer.from(await pdf.save());
+		await fs.writeFile(output, pdfData);
+	}
+	async function genPagePngOnePiece(writeToDisk) {
+		const result = [];
+		await go("print");
+		const slideContainers = page.locator(".print-slide-container");
+		const count = await slideContainers.count();
+		for (let i = 0; i < count; i++) {
+			progress.update(i + 1);
+			const id = await slideContainers.nth(i).getAttribute("id") || "";
+			const slideNo = +id.split("-")[0];
+			const buffer = await slideContainers.nth(i).screenshot({ omitBackground });
+			const filename = `${withClicks ? id : slideNo}.png`;
+			result.push({
+				slideIndex: slideNo - 1,
+				buffer,
+				filename
+			});
+			if (writeToDisk) await fs.writeFile(path.join(writeToDisk, filename), buffer);
+		}
+		return result;
+	}
+	async function genPagePngPerSlide(writeToDisk) {
+		const result = [];
+		const genScreenshot = async (no, clicks) => {
+			await go(no, clicks);
+			const buffer = await page.screenshot({ omitBackground });
+			const filename = `${no.toString().padStart(2, "0")}${clicks ? `-${clicks}` : ""}.png`;
+			result.push({
+				slideIndex: no - 1,
+				buffer,
+				filename
+			});
+			if (writeToDisk) await fs.writeFile(path.join(writeToDisk, filename), buffer);
+		};
+		for (const no of pages) await genPageWithClicks(genScreenshot, no);
+		return result;
+	}
+	function genPagePdf() {
+		if (!output.endsWith(".pdf")) output = `${output}.pdf`;
+		return perSlide ? genPagePdfPerSlide() : genPagePdfOnePiece();
+	}
+	async function genPagePng(writeToDisk) {
+		if (writeToDisk) {
+			await fs.rm(writeToDisk, {
+				force: true,
+				recursive: true
+			});
+			await fs.mkdir(writeToDisk, { recursive: true });
+		}
+		return perSlide ? genPagePngPerSlide(writeToDisk) : genPagePngOnePiece(writeToDisk);
+	}
+	async function genPageMd() {
+		const pngs = await genPagePng(dirname(output));
+		const content = slides.map(({ title, index, note }) => pngs.filter(({ slideIndex }) => slideIndex === index).map(({ filename }) => `![${title || index + 1}](./${filename})\n\n`).join("") + (note ? `${note.trim()}\n\n` : "")).join("---\n\n");
+		await fs.writeFile(ensureSuffix(".md", output), content);
+	}
+	async function genPagePptx(pngs) {
+		const { default: PptxGenJS } = await import("pptxgenjs");
+		const pptx = new PptxGenJS();
+		const layoutName = `${width}x${height}`;
+		pptx.defineLayout({
+			name: layoutName,
+			width: width / 96,
+			height: height / 96
+		});
+		pptx.layout = layoutName;
+		const titleSlide = slides[0];
+		pptx.author = titleSlide?.frontmatter?.author;
+		pptx.company = "Created using Slidev";
+		if (titleSlide?.title) pptx.title = titleSlide?.title;
+		if (titleSlide?.frontmatter?.info) pptx.subject = titleSlide?.frontmatter?.info;
+		pngs.forEach(({ slideIndex, buffer: buffer$1 }) => {
+			const slide = pptx.addSlide();
+			slide.background = { data: `data:image/png;base64,${buffer$1.toString("base64")}` };
+			const note = slides[slideIndex].note;
+			if (note) slide.addNotes(note);
+		});
+		const buffer = await pptx.write({ outputType: "nodebuffer" });
+		if (!output.endsWith(".pptx")) output = `${output}.pptx`;
+		await fs.writeFile(output, buffer);
+	}
+	function addPdfMetadata(pdf) {
+		const titleSlide = slides[0];
+		if (titleSlide?.title) pdf.setTitle(titleSlide.title);
+		if (titleSlide?.frontmatter?.info) pdf.setSubject(titleSlide.frontmatter.info);
+		if (titleSlide?.frontmatter?.author) pdf.setAuthor(titleSlide.frontmatter.author);
+		if (titleSlide?.frontmatter?.keywords) if (Array.isArray(titleSlide?.frontmatter?.keywords)) pdf.setKeywords(titleSlide?.frontmatter?.keywords);
+		else pdf.setKeywords(titleSlide?.frontmatter?.keywords.split(","));
+	}
+	async function addTocToPdf(pdf) {
+		const outlinePdf = outlinePdfFactory(pdfLib);
+		const slideIndexes = await getSlidesIndex();
+		const tocTree = slides.filter((slide) => slide.title).reduce((acc, slide) => {
+			addToTree(acc, slide, slideIndexes);
+			return acc;
+		}, []);
+		const outline = makeOutline(tocTree);
+		return await outlinePdf({
+			outline,
+			pdf
+		});
+	}
+}
+function getExportOptions(args, options, outFilename) {
+	const config = {
+		...options.data.config.export,
+		...args,
+		...clearUndefined({
+			waitUntil: args["wait-until"],
+			withClicks: args["with-clicks"],
+			executablePath: args["executable-path"],
+			withToc: args["with-toc"],
+			perSlide: args["per-slide"],
+			omitBackground: args["omit-background"]
+		})
+	};
+	const { entry, output, format, timeout, wait, waitUntil, range: range$1, dark, withClicks, executablePath, withToc, perSlide, scale, omitBackground } = config;
+	outFilename = output || options.data.config.exportFilename || outFilename || `${path.basename(entry, ".md")}-export`;
+	return {
+		output: outFilename,
+		slides: options.data.slides,
+		total: options.data.slides.length,
+		range: range$1,
+		format: format || "pdf",
+		timeout: timeout ?? 3e4,
+		wait: wait ?? 0,
+		waitUntil: waitUntil === "none" ? void 0 : waitUntil ?? "networkidle",
+		dark: dark || options.data.config.colorSchema === "dark",
+		routerMode: options.data.config.routerMode,
+		width: options.data.config.canvasWidth,
+		height: Math.round(options.data.config.canvasWidth / options.data.config.aspectRatio),
+		withClicks: withClicks ?? format === "pptx",
+		executablePath,
+		withToc: withToc || false,
+		perSlide: perSlide || false,
+		scale: scale || 2,
+		omitBackground: omitBackground ?? false
+	};
+}
+async function importPlaywright() {
+	const { userRoot, userWorkspaceRoot } = await getRoots();
+	try {
+		return await import(await resolve$1("playwright-chromium", { url: userRoot }));
+	} catch {}
+	if (userWorkspaceRoot !== userRoot) try {
+		return await import(await resolve$1("playwright-chromium", { url: userWorkspaceRoot }));
+	} catch {}
+	const { resolveGlobal } = await import("resolve-global");
+	try {
+		const imported = await import(resolveGlobal("playwright-chromium"));
+		return imported.default ?? imported;
+	} catch {}
+	try {
+		return await import("playwright-chromium");
+	} catch {}
+	throw new Error("The exporting for Slidev is powered by Playwright, please install it via `npm i -D playwright-chromium`");
+}
+
+//#endregion
+export { exportNotes, exportSlides, getExportOptions };

package/dist/index.d.ts

@@ -1,14 +1,19 @@
-import * as vite from 'vite';
-import { InlineConfig, PluginOption } from 'vite';
-import { ResolvedSlidevOptions, SlidevServerOptions, SlidevEntryOptions, ResolvedSlidevUtils, SlidevPluginOptions } from '@slidev/types';
-import * as fs from '@slidev/parser/fs';
-export { fs as parser };
+import * as vite0 from "vite";
+import { InlineConfig, PluginOption } from "vite";
+import * as parser from "@slidev/parser/fs";
+import { ResolvedSlidevOptions, ResolvedSlidevUtils, SlidevEntryOptions, SlidevPluginOptions, SlidevServerOptions } from "@slidev/types";
 
-declare function createServer(options: ResolvedSlidevOptions, viteConfig?: InlineConfig, serverOptions?: SlidevServerOptions): Promise<vite.ViteDevServer>;
+//#region node/commands/serve.d.ts
+declare function createServer(options: ResolvedSlidevOptions, viteConfig?: InlineConfig, serverOptions?: SlidevServerOptions): Promise<vite0.ViteDevServer>;
 
+//#endregion
+//#region node/options.d.ts
 declare function resolveOptions(entryOptions: SlidevEntryOptions, mode: ResolvedSlidevOptions['mode']): Promise<ResolvedSlidevOptions>;
 declare function createDataUtils(resolved: Omit<ResolvedSlidevOptions, 'utils'>): Promise<ResolvedSlidevUtils>;
 
+//#endregion
+//#region node/vite/index.d.ts
 declare function ViteSlidevPlugin(options: ResolvedSlidevOptions, pluginOptions?: SlidevPluginOptions, serverOptions?: SlidevServerOptions): Promise<PluginOption[]>;
 
-export { ViteSlidevPlugin, createDataUtils, createServer, resolveOptions };
+//#endregion
+export { ViteSlidevPlugin, createDataUtils, createServer, parser, resolveOptions };

package/dist/index.js

@@ -1,17 +1,5 @@
-import {
-  createServer
-} from "./chunk-BCA62OS7.js";
-import {
-  ViteSlidevPlugin,
-  createDataUtils,
-  parser,
-  resolveOptions
-} from "./chunk-Y2DHOFI5.js";
-import "./chunk-TJFRPB4N.js";
-export {
-  ViteSlidevPlugin,
-  createDataUtils,
-  createServer,
-  parser,
-  resolveOptions
-};
+import { ViteSlidevPlugin, createDataUtils, parser, resolveOptions } from "./shared-bpaLqEdy.js";
+import "./resolver-BShaA6qw.js";
+import { createServer } from "./serve-Cg-fgcfD.js";
+
+export { ViteSlidevPlugin, createDataUtils, createServer, parser, resolveOptions };

package/dist/resolver-BShaA6qw.js

@@ -0,0 +1,155 @@
+import { dirname, join, relative, resolve } from "node:path";
+import process from "node:process";
+import { underline, yellow } from "ansis";
+import * as fs$1 from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ensurePrefix, slash } from "@antfu/utils";
+import { resolvePath } from "mlly";
+import { parseNi, run } from "@antfu/ni";
+import globalDirs from "global-directory";
+import prompts from "prompts";
+import { resolveGlobal } from "resolve-global";
+import { findClosestPkgJsonPath, findDepPkgJsonPath } from "vitefu";
+
+//#region node/resolver.ts
+const cliRoot = fileURLToPath(new URL("..", import.meta.url));
+const isInstalledGlobally = {};
+/**
+* Resolve path for import url on Vite client side
+*/
+async function resolveImportUrl(id) {
+	return toAtFS(await resolveImportPath(id, true));
+}
+function toAtFS(path$1) {
+	return `/@fs${ensurePrefix("/", slash(path$1))}`;
+}
+async function resolveImportPath(importName, ensure = false) {
+	try {
+		return await resolvePath(importName, { url: import.meta.url });
+	} catch {}
+	if (isInstalledGlobally.value) try {
+		return resolveGlobal(importName);
+	} catch {}
+	if (ensure) throw new Error(`Failed to resolve package "${importName}"`);
+}
+async function findPkgRoot(dep, parent, ensure = false) {
+	const pkgJsonPath = await findDepPkgJsonPath(dep, parent);
+	const path$1 = pkgJsonPath ? dirname(pkgJsonPath) : isInstalledGlobally.value ? await findGlobalPkgRoot(dep, false) : void 0;
+	if (ensure && !path$1) throw new Error(`Failed to resolve package "${dep}"`);
+	return path$1;
+}
+async function findGlobalPkgRoot(name, ensure = false) {
+	const yarnPath = join(globalDirs.yarn.packages, name);
+	if (fs$1.existsSync(`${yarnPath}/package.json`)) return yarnPath;
+	const npmPath = join(globalDirs.npm.packages, name);
+	if (fs$1.existsSync(`${npmPath}/package.json`)) return npmPath;
+	if (ensure) throw new Error(`Failed to resolve global package "${name}"`);
+}
+async function resolveEntry(entryRaw) {
+	if (!fs$1.existsSync(entryRaw) && !entryRaw.endsWith(".md") && !/[/\\]/.test(entryRaw)) entryRaw += ".md";
+	const entry = resolve(entryRaw);
+	if (!fs$1.existsSync(entry)) {
+		const { create } = await prompts({
+			name: "create",
+			type: "confirm",
+			initial: "Y",
+			message: `Entry file ${yellow(`"${entry}"`)} does not exist, do you want to create it?`
+		});
+		if (create) fs$1.copyFileSync(resolve(cliRoot, "template.md"), entry);
+		else process.exit(0);
+	}
+	return slash(entry);
+}
+/**
+* Create a resolver for theme or addon
+*/
+function createResolver(type, officials) {
+	async function promptForInstallation(pkgName) {
+		const { confirm } = await prompts({
+			name: "confirm",
+			initial: "Y",
+			type: "confirm",
+			message: `The ${type} "${pkgName}" was not found ${underline(isInstalledGlobally.value ? "globally" : "in your project")}, do you want to install it now?`
+		});
+		if (!confirm) process.exit(1);
+		if (isInstalledGlobally.value) await run(parseNi, ["-g", pkgName]);
+		else await run(parseNi, [pkgName]);
+	}
+	return async function(name, importer) {
+		const { userRoot } = await getRoots();
+		if (name === "none") return ["", null];
+		if (name[0] === "/") return [name, name];
+		if (name.startsWith("@/")) return [name, resolve(userRoot, name.slice(2))];
+		if (name[0] === "." || name[0] !== "@" && name.includes("/")) return [name, resolve(dirname(importer), name)];
+		if (name.startsWith(`@slidev/${type}-`) || name.startsWith(`slidev-${type}-`)) {
+			const pkgRoot = await findPkgRoot(name, importer);
+			if (!pkgRoot) await promptForInstallation(name);
+			return [name, await findPkgRoot(name, importer, true)];
+		}
+		{
+			const possiblePkgNames = [
+				`@slidev/${type}-${name}`,
+				`slidev-${type}-${name}`,
+				name
+			];
+			for (const pkgName$1 of possiblePkgNames) {
+				const pkgRoot = await findPkgRoot(pkgName$1, importer);
+				if (pkgRoot) return [pkgName$1, pkgRoot];
+			}
+		}
+		const pkgName = officials[name] ?? (name[0] === "@" ? name : `slidev-${type}-${name}`);
+		await promptForInstallation(pkgName);
+		return [pkgName, await findPkgRoot(pkgName, importer, true)];
+	};
+}
+function getUserPkgJson(userRoot) {
+	const path$1 = resolve(userRoot, "package.json");
+	if (fs$1.existsSync(path$1)) return JSON.parse(fs$1.readFileSync(path$1, "utf-8"));
+	return {};
+}
+function hasWorkspacePackageJSON(root) {
+	const path$1 = join(root, "package.json");
+	try {
+		fs$1.accessSync(path$1, fs$1.constants.R_OK);
+	} catch {
+		return false;
+	}
+	const content = JSON.parse(fs$1.readFileSync(path$1, "utf-8")) || {};
+	return !!content.workspaces;
+}
+function hasRootFile(root) {
+	const ROOT_FILES = ["pnpm-workspace.yaml"];
+	return ROOT_FILES.some((file) => fs$1.existsSync(join(root, file)));
+}
+/**
+* Search up for the nearest workspace root
+*/
+function searchForWorkspaceRoot(current, root = current) {
+	if (hasRootFile(current)) return current;
+	if (hasWorkspacePackageJSON(current)) return current;
+	const dir = dirname(current);
+	if (!dir || dir === current) return root;
+	return searchForWorkspaceRoot(dir, root);
+}
+let rootsInfo = null;
+async function getRoots(entry) {
+	if (rootsInfo) return rootsInfo;
+	if (!entry) throw new Error("[slidev] Cannot find roots without entry");
+	const userRoot = dirname(entry);
+	isInstalledGlobally.value = slash(relative(userRoot, process.argv[1])).includes("/.pnpm/") || (await import("is-installed-globally")).default;
+	const clientRoot = await findPkgRoot("@slidev/client", cliRoot, true);
+	const closestPkgRoot = dirname(await findClosestPkgJsonPath(userRoot) || userRoot);
+	const userPkgJson = getUserPkgJson(closestPkgRoot);
+	const userWorkspaceRoot = searchForWorkspaceRoot(closestPkgRoot);
+	rootsInfo = {
+		cliRoot,
+		clientRoot,
+		userRoot,
+		userPkgJson,
+		userWorkspaceRoot
+	};
+	return rootsInfo;
+}
+
+//#endregion
+export { createResolver, getRoots, isInstalledGlobally, resolveEntry, resolveImportPath, resolveImportUrl, toAtFS };

package/dist/serve-Cg-fgcfD.js

@@ -0,0 +1,14 @@
+import { resolveViteConfigs } from "./shared-bpaLqEdy.js";
+import { join } from "node:path";
+import process from "node:process";
+import { createServer } from "vite";
+
+//#region node/commands/serve.ts
+async function createServer$1(options, viteConfig = {}, serverOptions) {
+	process.env.EDITOR = process.env.EDITOR || "code";
+	const inlineConfig = await resolveViteConfigs(options, { optimizeDeps: { entries: [join(options.clientRoot, "main.ts")] } }, viteConfig, "serve", serverOptions);
+	return await createServer(inlineConfig);
+}
+
+//#endregion
+export { createServer$1 as createServer };