@slidev/cli 0.49.9 → 0.49.11

package/README.md

@@ -67,7 +67,7 @@ Install [Node.js >=18](https://nodejs.org/) and run the following command:
 npm init slidev
 ```
 
-Documentations:
+Documentation:
 **[English](https://sli.dev)** | [中文文档](https://cn.sli.dev) | [Français](https://fr.sli.dev) | [Español](https://es.sli.dev) | [Русский](https://ru.sli.dev) | [Português-BR](https://br.sli.dev)
 
 Discord: [chat.sli.dev](https://chat.sli.dev)
@@ -82,7 +82,7 @@ For a full example, you can check the [demo](https://github.com/slidevjs/slidev/
 - [Shiki](https://github.com/shikijs/shiki), [Monaco Editor](https://github.com/Microsoft/monaco-editor) - First-class code snippets support with live coding capability
 - [RecordRTC](https://recordrtc.org) - Built-in recording and camera view
 - [VueUse](https://vueuse.org) family - [`@vueuse/core`](https://github.com/vueuse/vueuse), [`@vueuse/motion`](https://github.com/vueuse/motion), etc.
-- [Iconify](https://iconify.design/) - Iconsets collection.
+- [Iconify](https://iconify.design/) - Icon sets collection.
 - [Drauu](https://github.com/antfu/drauu) - Drawing and annotations support
 - [KaTeX](https://katex.org/) - LaTeX math rendering.
 - [Mermaid](https://mermaid-js.github.io/mermaid) - Textual Diagrams.

package/dist/{build-HVOMXVYS.mjs → build-2HGCTOR5.mjs}

@@ -1,8 +1,7 @@
 import {
-  ViteSlidevPlugin,
   getIndexHtml,
-  mergeViteConfigs
-} from "./chunk-ZATTXN6U.mjs";
+  resolveViteConfigs
+} from "./chunk-4LA667A3.mjs";
 import "./chunk-LOUKLO2C.mjs";
 import "./chunk-RG2EEPCO.mjs";
 import "./chunk-BXO7ZPPU.mjs";
@@ -11,7 +10,7 @@ import "./chunk-BXO7ZPPU.mjs";
 import { resolve } from "node:path";
 import http from "node:http";
 import fs from "fs-extra";
-import { mergeConfig, build as viteBuild } from "vite";
+import { build as viteBuild } from "vite";
 import connect from "connect";
 import sirv from "sirv";
 async function build(options, viteConfig = {}, args) {
@@ -22,11 +21,9 @@ async function build(options, viteConfig = {}, args) {
   await fs.writeFile(indexPath, await getIndexHtml(options), "utf-8");
   let config = void 0;
   try {
-    let inlineConfig = await mergeViteConfigs(
+    const inlineConfig = await resolveViteConfigs(
       options,
-      viteConfig,
       {
-        root: options.userRoot,
         plugins: [
           {
             name: "resolve-config",
@@ -39,16 +36,9 @@ async function build(options, viteConfig = {}, args) {
           chunkSizeWarningLimit: 2e3
         }
       },
+      viteConfig,
       "build"
     );
-    inlineConfig = mergeConfig(
-      inlineConfig,
-      {
-        plugins: [
-          await ViteSlidevPlugin(options, inlineConfig.slidev || {})
-        ]
-      }
-    );
     await viteBuild(inlineConfig);
   } finally {
     if (originalIndexHTML != null)

package/dist/{chunk-ZATTXN6U.mjs → chunk-4LA667A3.mjs}

@@ -7146,14 +7146,14 @@ var require_dist = __commonJS({
 });
 
 // package.json
-var version = "0.49.9";
+var version = "0.49.11";
 
 // node/commands/shared.ts
-import { existsSync, promises as fs } from "node:fs";
-import { join } from "node:path";
-import { loadConfigFromFile, mergeConfig, resolveConfig } from "vite";
+import { existsSync as existsSync6, promises as fs8 } from "node:fs";
+import { join as join10 } from "node:path";
+import { loadConfigFromFile, mergeConfig as mergeConfig2 } from "vite";
 import MarkdownIt from "markdown-it";
-import { slash } from "@antfu/utils";
+import { slash as slash5 } from "@antfu/utils";
 
 // node/syntax/markdown-it/markdown-it-link.ts
 function markdownItLink(md) {
@@ -7223,183 +7223,9 @@ function updateFrontmatterPatch(slide, frontmatter) {
   }
 }
 
-// node/commands/shared.ts
-var sharedMd = MarkdownIt({ html: true });
-sharedMd.use(markdownItLink);
-function getSlideTitle(data) {
-  const tokens = sharedMd.parseInline(data.config.title, {});
-  const title = stringifyMarkdownTokens(tokens);
-  const slideTitle = data.config.titleTemplate.replace("%s", title);
-  return slideTitle === "Slidev - Slidev" ? "Slidev" : slideTitle;
-}
-function escapeHtml(unsafe) {
-  return JSON.stringify(
-    String(unsafe).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;")
-  );
-}
-async function getIndexHtml({ entry, clientRoot, roots, data }) {
-  let main = await fs.readFile(join(clientRoot, "index.html"), "utf-8");
-  let head = "";
-  let body = "";
-  const { info, author, keywords } = data.headmatter;
-  head += [
-    `<meta name="slidev:version" content="${version}">`,
-    `<meta charset="slidev:entry" content="${slash(entry)}">`,
-    `<link rel="icon" href="${data.config.favicon}">`,
-    `<title>${getSlideTitle(data)}</title>`,
-    info && `<meta name="description" content=${escapeHtml(info)}>`,
-    author && `<meta name="author" content=${escapeHtml(author)}>`,
-    keywords && `<meta name="keywords" content=${escapeHtml(Array.isArray(keywords) ? keywords.join(", ") : keywords)}>`
-  ].filter(Boolean).join("\n");
-  for (const root of roots) {
-    const path4 = join(root, "index.html");
-    if (!existsSync(path4))
-      continue;
-    const index = await fs.readFile(path4, "utf-8");
-    head += `
-${(index.match(/<head>([\s\S]*?)<\/head>/i)?.[1] || "").trim()}`;
-    body += `
-${(index.match(/<body>([\s\S]*?)<\/body>/i)?.[1] || "").trim()}`;
-  }
-  if (data.features.tweet)
-    body += '\n<script async src="https://platform.twitter.com/widgets.js"></script>';
-  if (data.config.fonts.webfonts.length && data.config.fonts.provider !== "none")
-    head += `
-<link rel="stylesheet" href="${generateGoogleFontsUrl(data.config.fonts)}" type="text/css">`;
-  main = main.replace("__ENTRY__", toAtFS(join(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
-  return main;
-}
-async function mergeViteConfigs({ roots, entry }, viteConfig, config, command) {
-  const configEnv = {
-    mode: "development",
-    command
-  };
-  const files = roots.map((i) => join(i, "vite.config.ts"));
-  for await (const file of files) {
-    if (!existsSync(file))
-      continue;
-    const viteConfig2 = await loadConfigFromFile(configEnv, file);
-    if (!viteConfig2?.config)
-      continue;
-    config = mergeConfig(config, viteConfig2.config);
-  }
-  config = mergeConfig(config, viteConfig);
-  const localConfig = await resolveConfig({}, command, entry);
-  config = mergeConfig(config, { slidev: localConfig.slidev || {} });
-  return config;
-}
-
-// node/parser.ts
-import * as parser from "@slidev/parser/fs";
-
-// node/integrations/themes.ts
-import { join as join2 } from "node:path";
-import fs2 from "fs-extra";
-import { satisfies } from "semver";
-var officialThemes = {
-  "none": "",
-  "default": "@slidev/theme-default",
-  "seriph": "@slidev/theme-seriph",
-  "apple-basic": "@slidev/theme-apple-basic",
-  "shibainu": "@slidev/theme-shibainu",
-  "bricks": "@slidev/theme-bricks"
-};
-var resolveTheme = createResolver("theme", officialThemes);
-async function getThemeMeta(name, root) {
-  const path4 = join2(root, "package.json");
-  if (!fs2.existsSync(path4))
-    return {};
-  const { slidev = {}, engines = {} } = await fs2.readJSON(path4);
-  if (engines.slidev && !satisfies(version, engines.slidev, { includePrerelease: true }))
-    throw new Error(`[slidev] theme "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
-  return slidev;
-}
-
-// node/integrations/addons.ts
-import { resolve } from "node:path";
-import fs3 from "fs-extra";
-import { satisfies as satisfies2 } from "semver";
-async function resolveAddons(addonsInConfig) {
-  const { userRoot, userPkgJson } = await getRoots();
-  const resolved = [];
-  const resolveAddonNameAndRoot = createResolver("addon", {});
-  async function resolveAddon(name, parent) {
-    const [, pkgRoot] = await resolveAddonNameAndRoot(name, parent);
-    if (!pkgRoot)
-      return;
-    resolved.push(pkgRoot);
-    const { slidev = {}, engines = {} } = await fs3.readJSON(resolve(pkgRoot, "package.json"));
-    if (engines.slidev && !satisfies2(version, engines.slidev, { includePrerelease: true }))
-      throw new Error(`[slidev] addon "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
-    if (Array.isArray(slidev.addons))
-      await Promise.all(slidev.addons.map((addon) => resolveAddon(addon, pkgRoot)));
-  }
-  if (Array.isArray(addonsInConfig))
-    await Promise.all(addonsInConfig.map((addon) => resolveAddon(addon, userRoot)));
-  if (Array.isArray(userPkgJson.slidev?.addons))
-    await Promise.all(userPkgJson.slidev.addons.map((addon) => resolveAddon(addon, userRoot)));
-  return resolved;
-}
-
-// node/options.ts
-import { uniq } from "@antfu/utils";
-import Debug from "debug";
-import mm from "micromatch";
-var debug = Debug("slidev:options");
-async function resolveOptions(options, mode) {
-  const entry = await resolveEntry(options.entry);
-  const rootsInfo = await getRoots(entry);
-  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
-  let themeRaw = options.theme || loaded.headmatter.theme;
-  themeRaw = themeRaw === null ? "none" : themeRaw || "default";
-  const [theme, themeRoot] = await resolveTheme(themeRaw, entry);
-  const themeRoots = themeRoot ? [themeRoot] : [];
-  const themeMeta = themeRoot ? await getThemeMeta(theme, themeRoot) : void 0;
-  const config = parser.resolveConfig(loaded.headmatter, themeMeta, options.entry);
-  const addonRoots = await resolveAddons(config.addons);
-  const roots = uniq([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
-  debug({
-    ...rootsInfo,
-    ...options,
-    config,
-    mode,
-    entry,
-    themeRaw,
-    theme,
-    themeRoots,
-    addonRoots,
-    roots
-  });
-  const data = {
-    ...loaded,
-    config,
-    themeMeta
-  };
-  const resolved = {
-    ...rootsInfo,
-    ...options,
-    data,
-    mode,
-    entry,
-    themeRaw,
-    theme,
-    themeRoots,
-    addonRoots,
-    roots,
-    utils: createDataUtils(data)
-  };
-  return resolved;
-}
-function createDataUtils(data) {
-  const monacoTypesIgnorePackagesMatches = (data.config.monacoTypesIgnorePackages || []).map((i) => mm.matcher(i));
-  return {
-    isMonacoTypesIgnored: (pkg) => monacoTypesIgnorePackagesMatches.some((i) => i(pkg))
-  };
-}
-
 // node/vite/index.ts
-import { join as join10 } from "node:path";
-import { existsSync as existsSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
 import process2 from "node:process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import Icons from "unplugin-icons/vite";
@@ -7409,18 +7235,18 @@ import ServerRef from "vite-plugin-vue-server-ref";
 import { notNullish as notNullish2 } from "@antfu/utils";
 
 // node/integrations/drawings.ts
-import { basename, dirname, join as join3, resolve as resolve2 } from "node:path";
-import fs4 from "fs-extra";
+import { basename, dirname, join, resolve } from "node:path";
+import fs from "fs-extra";
 import fg from "fast-glob";
 function resolveDrawingsDir(options) {
-  return options.data.config.drawings.persist ? resolve2(
+  return options.data.config.drawings.persist ? resolve(
     dirname(options.entry),
     options.data.config.drawings.persist
   ) : void 0;
 }
 async function loadDrawings(options) {
   const dir = resolveDrawingsDir(options);
-  if (!dir || !fs4.existsSync(dir))
+  if (!dir || !fs.existsSync(dir))
     return {};
   const files = await fg("*.svg", {
     onlyFiles: true,
@@ -7433,7 +7259,7 @@ async function loadDrawings(options) {
     const num = +basename(path4, ".svg");
     if (Number.isNaN(num))
       return;
-    const content = await fs4.readFile(path4, "utf8");
+    const content = await fs.readFile(path4, "utf8");
     const lines = content.split(/\n/g);
     obj[num.toString()] = lines.slice(1, -1).join("\n");
   }));
@@ -7446,7 +7272,7 @@ async function writeDrawings(options, drawing) {
   const width = options.data.config.canvasWidth;
   const height = Math.round(width / options.data.config.aspectRatio);
   const SVG_HEAD = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">`;
-  await fs4.ensureDir(dir);
+  await fs.ensureDir(dir);
   return Promise.all(
     Object.entries(drawing).map(async ([key, value]) => {
       if (!value)
@@ -7454,16 +7280,16 @@ async function writeDrawings(options, drawing) {
       const svg = `${SVG_HEAD}
 ${value}
 </svg>`;
-      await fs4.writeFile(join3(dir, `${key}.svg`), svg, "utf-8");
+      await fs.writeFile(join(dir, `${key}.svg`), svg, "utf-8");
     })
   );
 }
 
 // node/vite/extendConfig.ts
-import { join as join4 } from "node:path";
+import { join as join2 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { mergeConfig as mergeConfig2 } from "vite";
-import { slash as slash2, uniq as uniq2 } from "@antfu/utils";
+import { mergeConfig } from "vite";
+import { slash, uniq } from "@antfu/utils";
 import { createResolve } from "mlly";
 var INCLUDE_GLOBAL = [
   "@typescript/ata",
@@ -7574,16 +7400,16 @@ function createConfigPlugin(options) {
         server: {
           fs: {
             strict: true,
-            allow: uniq2([
+            allow: uniq([
               options.userWorkspaceRoot,
               options.clientRoot,
               // Special case for PNPM global installation
-              isInstalledGlobally.value ? slash2(options.cliRoot).replace(/\/\.pnpm\/.*$/gi, "") : options.cliRoot,
+              isInstalledGlobally.value ? slash(options.cliRoot).replace(/\/\.pnpm\/.*$/gi, "") : options.cliRoot,
               ...options.roots
             ])
           }
         },
-        publicDir: join4(options.userRoot, "public"),
+        publicDir: join2(options.userRoot, "public"),
         build: {
           rollupOptions: {
             output: {
@@ -7616,10 +7442,10 @@ function createConfigPlugin(options) {
         return id.includes("/@slidev/") || id.includes("/slidev/packages/client/") || id.includes("/@vueuse/");
       }
       if (isInstalledGlobally.value) {
-        injection.cacheDir = join4(options.cliRoot, "node_modules/.vite");
+        injection.cacheDir = join2(options.cliRoot, "node_modules/.vite");
         injection.root = options.cliRoot;
       }
-      return mergeConfig2(injection, config);
+      return mergeConfig(injection, config);
     },
     configureServer(server) {
       return () => {
@@ -7647,6 +7473,7 @@ function getDefine(options) {
     __SLIDEV_FEATURE_RECORD__: JSON.stringify(options.data.config.record === true || options.data.config.record === options.mode),
     __SLIDEV_FEATURE_PRESENTER__: JSON.stringify(options.data.config.presenter === true || options.data.config.presenter === options.mode),
     __SLIDEV_FEATURE_PRINT__: JSON.stringify(options.mode === "export" || options.mode === "build" && [true, "true", "auto"].includes(options.data.config.download)),
+    __SLIDEV_FEATURE_WAKE_LOCK__: JSON.stringify(options.data.config.wakeLock === true || options.data.config.wakeLock === options.mode),
     __SLIDEV_HAS_SERVER__: options.mode !== "build" ? "true" : "false"
   };
 }
@@ -7701,15 +7528,15 @@ console.warn('/@slidev/titles.md is deprecated, import from #slidev/title-render
 };
 
 // node/virtual/global-layers.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync } from "node:fs";
+import { join as join3 } from "node:path";
 var templateGlobalLayers = {
   id: `/@slidev/global-layers`,
   getContent({ roots }) {
     const imports = [];
     let n = 0;
     function getComponent(names) {
-      const components = roots.flatMap((root) => names.map((name) => join5(root, name))).filter((i) => existsSync2(i));
+      const components = roots.flatMap((root) => names.map((name) => join3(root, name))).filter((i) => existsSync(i));
       imports.push(components.map((path4, i) => `import __n${n}_${i} from '${toAtFS(path4)}'`).join("\n"));
       const render = components.map((_, i) => `h(__n${n}_${i})`).join(",");
       n++;
@@ -7731,17 +7558,17 @@ var templateGlobalLayers = {
 };
 
 // node/virtual/nav-controls.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join4 } from "node:path";
 var templateNavControls = {
   id: "/@slidev/custom-nav-controls",
   getContent({ roots }) {
     const components = roots.flatMap((root) => {
       return [
-        join6(root, "custom-nav-controls.vue"),
-        join6(root, "CustomNavControls.vue")
+        join4(root, "custom-nav-controls.vue"),
+        join4(root, "CustomNavControls.vue")
       ];
-    }).filter((i) => existsSync3(i));
+    }).filter((i) => existsSync2(i));
     const imports = components.map((i, idx) => `import __n${idx} from '${toAtFS(i)}'`).join("\n");
     const render = components.map((i, idx) => `h(__n${idx})`).join(",");
     return `${imports}
@@ -7775,15 +7602,15 @@ ${Object.entries(layouts).map(([k, v]) => `"${k}": ${v}`).join(",\n")}
 };
 
 // node/virtual/monaco-deps.ts
-import { resolve as resolve3 } from "node:path";
-import { uniq as uniq3 } from "@antfu/utils";
+import { resolve as resolve2 } from "node:path";
+import { uniq as uniq2 } from "@antfu/utils";
 var templateMonacoRunDeps = {
   id: "/@slidev/monaco-run-deps",
   getContent: async ({ userRoot, data }, _ctx, pluginCtx) => {
     if (!data.features.monaco)
       return "";
-    const deps = uniq3(data.features.monaco.deps.concat(data.config.monacoTypesAdditionalPackages));
-    const importerPath = resolve3(userRoot, "./snippets/__importer__.ts");
+    const deps = uniq2(data.features.monaco.deps.concat(data.config.monacoTypesAdditionalPackages));
+    const importerPath = resolve2(userRoot, "./snippets/__importer__.ts");
     let result = "";
     for (let i = 0; i < deps.length; i++) {
       const specifier = deps[i];
@@ -7804,19 +7631,19 @@ var templateMonacoRunDeps = {
 
 // node/virtual/monaco-types.ts
 import { builtinModules } from "node:module";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { join as join5, resolve as resolve3 } from "node:path";
 import fg2 from "fast-glob";
-import { uniq as uniq4 } from "@antfu/utils";
+import { uniq as uniq3 } from "@antfu/utils";
 var templateMonacoTypes = {
   id: "/@slidev/monaco-types",
   getContent: async ({ userRoot, data, utils }) => {
     if (!data.features.monaco)
       return "";
-    const typesRoot = join7(userRoot, "snippets");
+    const typesRoot = join5(userRoot, "snippets");
     const files = await fg2(["**/*.ts", "**/*.mts", "**/*.cts"], { cwd: typesRoot });
     let result = 'import { addFile } from "@slidev/client/setup/monaco.ts"\n';
     for (const file of files) {
-      const url = `${toAtFS(resolve4(typesRoot, file))}?monaco-types&raw`;
+      const url = `${toAtFS(resolve3(typesRoot, file))}?monaco-types&raw`;
       result += `addFile(() => import(${JSON.stringify(url)}), ${JSON.stringify(file)})
 `;
     }
@@ -7835,7 +7662,7 @@ var templateMonacoTypes = {
     let deps = [...data.config.monacoTypesAdditionalPackages];
     if (data.config.monacoTypesSource === "local")
       deps.push(...data.features.monaco.types);
-    deps = uniq4(deps.map((specifier) => {
+    deps = uniq3(deps.map((specifier) => {
       if (specifier[0] === ".")
         return "";
       return mapModuleNameToModule(specifier);
@@ -7850,16 +7677,16 @@ var templateMonacoTypes = {
 };
 
 // node/virtual/setups.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 function createSetupTemplate(name) {
   return {
     id: `/@slidev/setups/${name}`,
     getContent({ roots }) {
       const setups = roots.flatMap((i) => {
-        const path4 = join8(i, "setup", name);
+        const path4 = join6(i, "setup", name);
         return [".ts", ".mts", ".js", ".mjs"].map((ext) => path4 + ext);
-      }).filter((i) => existsSync4(i));
+      }).filter((i) => existsSync3(i));
       const imports = [];
       setups.forEach((path4, idx) => {
         imports.push(`import __n${idx} from '${toAtFS(path4)}'`);
@@ -7873,7 +7700,7 @@ var setupModules = ["shiki", "code-runners", "monaco", "mermaid", "main", "root"
 var templateSetups = setupModules.map(createSetupTemplate);
 
 // node/setups/shiki.ts
-import fs5 from "node:fs/promises";
+import fs2 from "node:fs/promises";
 async function loadShikiSetups(clientRoot, roots) {
   const result = await loadSetups(
     clientRoot,
@@ -7883,7 +7710,7 @@ async function loadShikiSetups(clientRoot, roots) {
       /** @deprecated */
       async loadTheme(path4) {
         console.warn("[slidev] `loadTheme` in `setup/shiki.ts` is deprecated. Pass directly the theme name it's supported by Shiki. For custom themes, load it manually via `JSON.parse(fs.readFileSync(path, 'utf-8'))` and pass the raw JSON object instead.");
-        return JSON.parse(await fs5.readFile(path4, "utf-8"));
+        return JSON.parse(await fs2.readFile(path4, "utf-8"));
       }
     },
     {},
@@ -7996,13 +7823,13 @@ ${slides.join(",\n")}
 };
 
 // node/virtual/styles.ts
-import { join as join9 } from "node:path";
-import { existsSync as existsSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
 var templateStyle = {
   id: "/@slidev/styles",
   getContent: async ({ data, clientRoot, roots }) => {
     function resolveUrlOfClient(name) {
-      return toAtFS(join9(clientRoot, name));
+      return toAtFS(join7(clientRoot, name));
     }
     const imports = [
       `import "${resolveUrlOfClient("styles/vars.css")}"`,
@@ -8013,14 +7840,14 @@ var templateStyle = {
     ];
     for (const root of roots) {
       const styles = [
-        join9(root, "styles", "index.ts"),
-        join9(root, "styles", "index.js"),
-        join9(root, "styles", "index.css"),
-        join9(root, "styles.css"),
-        join9(root, "style.css")
+        join7(root, "styles", "index.ts"),
+        join7(root, "styles", "index.js"),
+        join7(root, "styles", "index.css"),
+        join7(root, "styles.css"),
+        join7(root, "style.css")
       ];
       for (const style of styles) {
-        if (existsSync5(style)) {
+        if (existsSync4(style)) {
           imports.push(`import "${toAtFS(style)}"`);
           continue;
         }
@@ -8094,6 +7921,116 @@ var templates = [
   templateLegacyTitles
 ];
 
+// node/options.ts
+import { uniq as uniq4 } from "@antfu/utils";
+import Debug from "debug";
+import mm from "micromatch";
+
+// node/parser.ts
+import * as parser from "@slidev/parser/fs";
+
+// node/integrations/themes.ts
+import { join as join8 } from "node:path";
+import fs3 from "fs-extra";
+import { satisfies } from "semver";
+var officialThemes = {
+  "none": "",
+  "default": "@slidev/theme-default",
+  "seriph": "@slidev/theme-seriph",
+  "apple-basic": "@slidev/theme-apple-basic",
+  "shibainu": "@slidev/theme-shibainu",
+  "bricks": "@slidev/theme-bricks"
+};
+var resolveTheme = createResolver("theme", officialThemes);
+async function getThemeMeta(name, root) {
+  const path4 = join8(root, "package.json");
+  if (!fs3.existsSync(path4))
+    return {};
+  const { slidev = {}, engines = {} } = await fs3.readJSON(path4);
+  if (engines.slidev && !satisfies(version, engines.slidev, { includePrerelease: true }))
+    throw new Error(`[slidev] theme "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
+  return slidev;
+}
+
+// node/integrations/addons.ts
+import { resolve as resolve4 } from "node:path";
+import fs4 from "fs-extra";
+import { satisfies as satisfies2 } from "semver";
+async function resolveAddons(addonsInConfig) {
+  const { userRoot, userPkgJson } = await getRoots();
+  const resolved = [];
+  const resolveAddonNameAndRoot = createResolver("addon", {});
+  async function resolveAddon(name, parent) {
+    const [, pkgRoot] = await resolveAddonNameAndRoot(name, parent);
+    if (!pkgRoot)
+      return;
+    resolved.push(pkgRoot);
+    const { slidev = {}, engines = {} } = await fs4.readJSON(resolve4(pkgRoot, "package.json"));
+    if (engines.slidev && !satisfies2(version, engines.slidev, { includePrerelease: true }))
+      throw new Error(`[slidev] addon "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
+    if (Array.isArray(slidev.addons))
+      await Promise.all(slidev.addons.map((addon) => resolveAddon(addon, pkgRoot)));
+  }
+  if (Array.isArray(addonsInConfig))
+    await Promise.all(addonsInConfig.map((addon) => resolveAddon(addon, userRoot)));
+  if (Array.isArray(userPkgJson.slidev?.addons))
+    await Promise.all(userPkgJson.slidev.addons.map((addon) => resolveAddon(addon, userRoot)));
+  return resolved;
+}
+
+// node/options.ts
+var debug = Debug("slidev:options");
+async function resolveOptions(options, mode) {
+  const entry = await resolveEntry(options.entry);
+  const rootsInfo = await getRoots(entry);
+  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
+  let themeRaw = options.theme || loaded.headmatter.theme;
+  themeRaw = themeRaw === null ? "none" : themeRaw || "default";
+  const [theme, themeRoot] = await resolveTheme(themeRaw, entry);
+  const themeRoots = themeRoot ? [themeRoot] : [];
+  const themeMeta = themeRoot ? await getThemeMeta(theme, themeRoot) : void 0;
+  const config = parser.resolveConfig(loaded.headmatter, themeMeta, options.entry);
+  const addonRoots = await resolveAddons(config.addons);
+  const roots = uniq4([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
+  debug({
+    ...rootsInfo,
+    ...options,
+    config,
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots
+  });
+  const data = {
+    ...loaded,
+    config,
+    themeMeta
+  };
+  const resolved = {
+    ...rootsInfo,
+    ...options,
+    data,
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots,
+    utils: createDataUtils(data)
+  };
+  return resolved;
+}
+function createDataUtils(data) {
+  const monacoTypesIgnorePackagesMatches = (data.config.monacoTypesIgnorePackages || []).map((i) => mm.matcher(i));
+  return {
+    isMonacoTypesIgnored: (pkg) => monacoTypesIgnorePackagesMatches.some((i) => i(pkg))
+  };
+}
+
 // node/vite/loaders.ts
 var regexId = /^\/@slidev\/slide\/(\d+)\.(md|json)(?:\?import)?$/;
 var regexIdQuery = /(\d+)\.(md|json|frontmatter)$/;
@@ -8148,17 +8085,15 @@ function createSlidesLoader(options, pluginOptions, serverOptions) {
       if (now - _layouts_cache_time < 2e3)
         return _layouts_cache;
       const layouts = {};
-      for (const root of [...roots, clientRoot]) {
+      for (const root of [clientRoot, ...roots]) {
         const layoutPaths = await fg3("layouts/**/*.{vue,ts}", {
           cwd: root,
           absolute: true,
           suppressErrors: true
         });
         for (const layoutPath of layoutPaths) {
-          const layout = path.basename(layoutPath).replace(/\.\w+$/, "");
-          if (layouts[layout])
-            continue;
-          layouts[layout] = layoutPath;
+          const layoutName = path.basename(layoutPath).replace(/\.\w+$/, "");
+          layouts[layoutName] = layoutPath;
         }
       }
       _layouts_cache_time = now;
@@ -8325,6 +8260,7 @@ function createSlidesLoader(options, pluginOptions, serverOptions) {
                 ...withRenderedNote(slide),
                 frontmatter: void 0,
                 source: void 0,
+                importChain: void 0,
                 // remove raw content in build, optimize the bundle size
                 ...mode === "build" ? { raw: "", content: "", note: "" } : {}
               };
@@ -8512,7 +8448,7 @@ ${code}`;
 
 // node/vite/markdown.ts
 import Markdown from "unplugin-vue-markdown/vite";
-import { isTruthy, slash as slash4 } from "@antfu/utils";
+import { isTruthy, slash as slash3 } from "@antfu/utils";
 
 // ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.1.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/image-size/specialCharacters.js
 var SpecialCharacters;
@@ -9022,7 +8958,7 @@ function transformMagicMove(shiki, shikiOptions, configLineNumbers) {
 import lz2 from "lz-string";
 function transformMermaid(ctx) {
   ctx.s.replace(
-    /^```mermaid *(\{[^}]*\})?\n([\s\S]+?)\n```/gm,
+    /^```mermaid *(\{[^\n]*\})?\n([\s\S]+?)\n```/gm,
     (full, options = "", code = "") => {
       code = code.trim();
       options = options.trim() || "{}";
@@ -9049,11 +8985,11 @@ function transformPlantUml(ctx) {
 // node/syntax/transform/snippet.ts
 import path3 from "node:path";
 import lz3 from "lz-string";
-import fs7 from "fs-extra";
-import { slash as slash3 } from "@antfu/utils";
+import fs6 from "fs-extra";
+import { slash as slash2 } from "@antfu/utils";
 
 // node/vite/monacoWrite.ts
-import fs6 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path2 from "node:path";
 var monacoWriterWhitelist = /* @__PURE__ */ new Set();
 function createMonacoWriter({ userRoot }) {
@@ -9077,7 +9013,7 @@ function createMonacoWriter({ userRoot }) {
             }
             const filepath = path2.join(userRoot, file);
             console.log("[Slidev] Writing file:", filepath);
-            await fs6.writeFile(filepath, content, "utf-8");
+            await fs5.writeFile(filepath, content, "utf-8");
           }
         });
       });
@@ -9149,15 +9085,15 @@ function transformSnippet(ctx) {
     // eslint-disable-next-line regexp/no-super-linear-backtracking
     /^<<<\s*(\S.*?)(#[\w-]+)?\s*(?:\s(\S+?))?\s*(\{.*)?$/gm,
     (full, filepath = "", regionName = "", lang = "", meta = "") => {
-      const src = slash3(
+      const src = slash2(
         /^@\//.test(filepath) ? path3.resolve(options.userRoot, filepath.slice(2)) : path3.resolve(dir, filepath)
       );
       data.watchFiles.push(src);
-      const isAFile = fs7.statSync(src).isFile();
-      if (!fs7.existsSync(src) || !isAFile) {
+      const isAFile = fs6.statSync(src).isFile();
+      if (!fs6.existsSync(src) || !isAFile) {
         throw new Error(isAFile ? `Code snippet path not found: ${src}` : `Invalid code snippet option`);
       }
-      let content = fs7.readFileSync(src, "utf8");
+      let content = fs6.readFileSync(src, "utf8");
       slideInfo.snippetsUsed ??= {};
       slideInfo.snippetsUsed[src] = content;
       if (regionName) {
@@ -9242,7 +9178,7 @@ function transformMonaco(ctx) {
     return;
   }
   ctx.s.replace(
-    /^```(\w+) *\{monaco-diff\} *(?:(\{[^\n}]*\}) *)?\n([\s\S]+?)^~~~ *\n([\s\S]+?)^```/gm,
+    /^```(\w+) *\{monaco-diff\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^~~~ *\n([\s\S]+?)^```/gm,
     (full, lang = "ts", options = "{}", code, diff) => {
       lang = lang.trim();
       options = options.trim() || "{}";
@@ -9252,7 +9188,7 @@ function transformMonaco(ctx) {
     }
   );
   ctx.s.replace(
-    /^```(\w+) *\{monaco\} *(?:(\{[^}]*\}) *)?\n([\s\S]+?)^```/gm,
+    /^```(\w+) *\{monaco\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
     (full, lang = "ts", options = "{}", code) => {
       lang = lang.trim();
       options = options.trim() || "{}";
@@ -9261,7 +9197,7 @@ function transformMonaco(ctx) {
     }
   );
   ctx.s.replace(
-    /^```(\w+) *\{monaco-run\} *(?:(\{[^}]*\}) *)?\n([\s\S]+?)^```/gm,
+    /^```(\w+) *\{monaco-run\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
     (full, lang = "ts", options = "{}", code) => {
       lang = lang.trim();
       options = options.trim() || "{}";
@@ -9294,7 +9230,7 @@ $$
 async function createMarkdownPlugin(options, { markdown: mdOptions }) {
   const { data: { config }, roots, mode, entry, clientRoot } = options;
   const setups = [];
-  const entryPath = slash4(entry);
+  const entryPath = slash3(entry);
   let shiki;
   let shikiOptions;
   if (config.highlighter === "shiki") {
@@ -9450,9 +9386,9 @@ function createVueCompilerFlagsPlugin(options) {
 }
 
 // node/vite/monacoTypes.ts
-import fs8 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import { dirname as dirname2, resolve as resolve5 } from "node:path";
-import { slash as slash5 } from "@antfu/utils";
+import { slash as slash4 } from "@antfu/utils";
 import fg4 from "fast-glob";
 import { findDepPkgJsonPath } from "vitefu";
 function createMonacoTypesLoader({ userRoot, utils }) {
@@ -9474,8 +9410,8 @@ function createMonacoTypesLoader({ userRoot, utils }) {
         const pkgJsonPath = await findDepPkgJsonPath(pkg, importer);
         if (!pkgJsonPath)
           throw new Error(`Package "${pkg}" not found in "${importer}"`);
-        const root = slash5(dirname2(pkgJsonPath));
-        const pkgJson = JSON.parse(await fs8.readFile(pkgJsonPath, "utf-8"));
+        const root = slash4(dirname2(pkgJsonPath));
+        const pkgJson = JSON.parse(await fs7.readFile(pkgJsonPath, "utf-8"));
         let deps = Object.keys(pkgJson.dependencies ?? {});
         deps = deps.filter((pkg2) => !utils.isMonacoTypesIgnored(pkg2));
         return [
@@ -9585,7 +9521,7 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
     data: { config }
   } = options;
   const drawingData = await loadDrawings(options);
-  const publicRoots = [...themeRoots, ...addonRoots].map((i) => join10(i, "public")).filter(existsSync6);
+  const publicRoots = [...themeRoots, ...addonRoots].map((i) => join9(i, "public")).filter(existsSync5);
   const plugins = [
     createMarkdownPlugin(options, pluginOptions),
     createVuePlugin(options, pluginOptions),
@@ -9594,11 +9530,11 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
     Components({
       extensions: ["vue", "md", "js", "ts", "jsx", "tsx"],
       dirs: [
-        join10(options.clientRoot, "builtin"),
-        ...roots.map((i) => join10(i, "components")),
+        join9(options.clientRoot, "builtin"),
+        ...roots.map((i) => join9(i, "components")),
         "src/components",
         "components",
-        join10(process2.cwd(), "components")
+        join9(process2.cwd(), "components")
       ],
       include: [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/, /\.md$/, /\.md\?vue/],
       exclude: [],
@@ -9667,10 +9603,85 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
   return (await Promise.all(plugins)).flat().filter(notNullish2);
 }
 
+// node/commands/shared.ts
+var sharedMd = MarkdownIt({ html: true });
+sharedMd.use(markdownItLink);
+function getSlideTitle(data) {
+  const tokens = sharedMd.parseInline(data.config.title, {});
+  const title = stringifyMarkdownTokens(tokens);
+  const slideTitle = data.config.titleTemplate.replace("%s", title);
+  return slideTitle === "Slidev - Slidev" ? "Slidev" : slideTitle;
+}
+function escapeHtml(unsafe) {
+  return JSON.stringify(
+    String(unsafe).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;")
+  );
+}
+async function getIndexHtml({ entry, clientRoot, roots, data }) {
+  let main = await fs8.readFile(join10(clientRoot, "index.html"), "utf-8");
+  let head = "";
+  let body = "";
+  const { info, author, keywords } = data.headmatter;
+  head += [
+    `<meta name="slidev:version" content="${version}">`,
+    `<meta charset="slidev:entry" content="${slash5(entry)}">`,
+    `<link rel="icon" href="${data.config.favicon}">`,
+    `<title>${getSlideTitle(data)}</title>`,
+    info && `<meta name="description" content=${escapeHtml(info)}>`,
+    author && `<meta name="author" content=${escapeHtml(author)}>`,
+    keywords && `<meta name="keywords" content=${escapeHtml(Array.isArray(keywords) ? keywords.join(", ") : keywords)}>`
+  ].filter(Boolean).join("\n");
+  for (const root of roots) {
+    const path4 = join10(root, "index.html");
+    if (!existsSync6(path4))
+      continue;
+    const index = await fs8.readFile(path4, "utf-8");
+    head += `
+${(index.match(/<head>([\s\S]*?)<\/head>/i)?.[1] || "").trim()}`;
+    body += `
+${(index.match(/<body>([\s\S]*?)<\/body>/i)?.[1] || "").trim()}`;
+  }
+  if (data.features.tweet)
+    body += '\n<script async src="https://platform.twitter.com/widgets.js"></script>';
+  if (data.config.fonts.webfonts.length && data.config.fonts.provider !== "none")
+    head += `
+<link rel="stylesheet" href="${generateGoogleFontsUrl(data.config.fonts)}" type="text/css">`;
+  main = main.replace("__ENTRY__", toAtFS(join10(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
+  return main;
+}
+async function resolveViteConfigs(options, baseConfig, overrideConfigs, command, serverOptions) {
+  const configEnv = {
+    mode: command === "build" ? "production" : "development",
+    command
+  };
+  const files = options.roots.map((i) => join10(i, "vite.config.ts"));
+  for (const file of files) {
+    if (!existsSync6(file))
+      continue;
+    const viteConfig = await loadConfigFromFile(configEnv, file);
+    if (!viteConfig?.config)
+      continue;
+    baseConfig = mergeConfig2(baseConfig, viteConfig.config);
+  }
+  baseConfig = mergeConfig2(baseConfig, overrideConfigs);
+  baseConfig = mergeConfig2(baseConfig, {
+    configFile: false,
+    root: options.userRoot,
+    plugins: [
+      await ViteSlidevPlugin(options, baseConfig.slidev || {}, serverOptions)
+    ],
+    define: {
+      // Fixes Vue production mode breaking PDF Export #1245
+      __VUE_PROD_DEVTOOLS__: false
+    }
+  });
+  return baseConfig;
+}
+
 export {
   version,
   getIndexHtml,
-  mergeViteConfigs,
+  resolveViteConfigs,
   parser,
   resolveTheme,
   getThemeMeta,

package/dist/chunk-G75DCGK3.mjs

@@ -0,0 +1,29 @@
+import {
+  resolveViteConfigs
+} from "./chunk-4LA667A3.mjs";
+
+// node/commands/server.ts
+import { join } from "node:path";
+import process from "node:process";
+import { createServer as createViteServer } from "vite";
+async function createServer(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 createViteServer(inlineConfig);
+}
+
+export {
+  createServer
+};

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import {
   createServer
-} from "./chunk-DRWYFCYG.mjs";
+} from "./chunk-G75DCGK3.mjs";
 import {
   getThemeMeta,
   parser,
@@ -8,7 +8,7 @@ import {
   resolveOptions,
   resolveTheme,
   version
-} from "./chunk-ZATTXN6U.mjs";
+} from "./chunk-4LA667A3.mjs";
 import {
   loadSetups
 } from "./chunk-LOUKLO2C.mjs";
@@ -328,7 +328,7 @@ cli.command(
   }).strict().help(),
   async (args) => {
     const { entry, theme, base, download, out, inspect } = args;
-    const { build } = await import("./build-HVOMXVYS.mjs");
+    const { build } = await import("./build-2HGCTOR5.mjs");
     for (const entryFile of entry) {
       const options = await resolveOptions({ entry: entryFile, theme, inspect }, "build");
       if (download && !options.data.config.download)

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import {
   createServer
-} from "./chunk-DRWYFCYG.mjs";
+} from "./chunk-G75DCGK3.mjs";
 import {
   ViteSlidevPlugin,
   createDataUtils,
   parser,
   resolveOptions
-} from "./chunk-ZATTXN6U.mjs";
+} from "./chunk-4LA667A3.mjs";
 import "./chunk-LOUKLO2C.mjs";
 import "./chunk-RG2EEPCO.mjs";
 import "./chunk-BXO7ZPPU.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slidev/cli",
-  "version": "0.49.9",
+  "version": "0.49.11",
   "description": "Presentation slides for developers",
   "author": "antfu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -110,9 +110,9 @@
     "vitefu": "^0.2.5",
     "vue": "^3.4.27",
     "yargs": "^17.7.2",
-    "@slidev/types": "0.49.9",
-    "@slidev/parser": "0.49.9",
-    "@slidev/client": "0.49.9"
+    "@slidev/client": "0.49.11",
+    "@slidev/parser": "0.49.11",
+    "@slidev/types": "0.49.11"
   },
   "devDependencies": {
     "@hedgedoc/markdown-it-plugins": "^2.1.4",

package/template.md

@@ -49,23 +49,23 @@ transition: fade-out
 
 # What is Slidev?
 
-Slidev is a slides maker and presenter designed for developers, consist of the following features
+Slidev is a slide maker and accompanying presentation tool designed for developers. It consists of the following features:
 
-- 📝 **Text-based** - focus on the content with Markdown, and then style them later
-- 🎨 **Themable** - theme can be shared and used with npm packages
+- 📝 **Text-based** - focus on the content with Markdown, and apply styles later
+- 🎨 **Themable** - themes can be shared and used as npm packages
 - 🧑‍💻 **Developer Friendly** - code highlighting, live coding with autocompletion
-- 🤹 **Interactive** - embedding Vue components to enhance your expressions
+- 🤹 **Interactive** - embedding Vue components to enhance your slides
 - 🎥 **Recording** - built-in recording and camera view
-- 📤 **Portable** - export into PDF, PPTX, PNGs, or even a hostable SPA
-- 🛠 **Hackable** - anything possible on a webpage
+- 📤 **Portable** - export to PDF, PPTX, PNGs, or even a hostable SPA
+- 🛠 **Hackable** - virtually anything that's possible on a webpage is possible in Slidev
 
 <br>
 <br>
 
-Read more about [Why Slidev?](https://sli.dev/guide/why)
+Read more about Slidev in [Why Slidev?](https://sli.dev/guide/why)
 
 <!--
-You can have `style` tag in markdown to override the style for the current page.
+You can have `style` tags in markdown to override the style for the current page.
 Learn more: https://sli.dev/guide/syntax#embedded-styles
 -->
 
@@ -104,7 +104,7 @@ level: 2
 
 # Navigation
 
-Hover on the bottom-left corner to see the navigation's controls panel, [learn more](https://sli.dev/guide/navigation.html)
+Hover on the bottom-left corner to see the navigation's control panel, [learn more](https://sli.dev/guide/navigation.html)
 
 ## Keyboard Shortcuts
 
@@ -131,7 +131,7 @@ image: https://cover.sli.dev
 
 # Code
 
-Use code snippets and get the highlighting directly, and even types hover![^1]
+Use code snippets and get automatic highlighting, and even types hover![^1]
 
 ```ts {all|5|7|7-8|10|all} twoslash
 // TwoSlash enables TypeScript hover information
@@ -176,7 +176,7 @@ doubled.value = 2
 
 You can use Vue components directly inside your slides.
 
-We have provided a few built-in components like `<Tweet/>` and `<Youtube/>` that you can use directly. And adding your custom components is also super easy.
+We have provided a few built-in components like `<Tweet/>` and `<Youtube/>` that you can use directly. Adding your own custom components is also super easy.
 
 ```html
 <Counter :count="10" />
@@ -200,7 +200,7 @@ Check out [the guides](https://sli.dev/builtin/components.html) for more.
 </div>
 
 <!--
-Presenter note with **bold**, *italic*, and ~~striked~~ text.
+Presenter notes with **bold**, *italic*, and ~~strike~~ text.
 
 Also, HTML elements are valid:
 <div class="flex w-full">
@@ -215,7 +215,7 @@ class: px-20
 
 # Themes
 
-Slidev comes with powerful theming support. Themes can provide styles, layouts, components, or even configurations for tools. Switching between themes by just **one edit** in your frontmatter:
+Slidev comes with powerful theming support. Themes can provide styles, layouts, components, or even configurations for tools. Switch between themes on a per-slide basis with just **one change** in your frontmatter:
 
 <div grid="~ cols-2 gap-2" m="t-2">
 
@@ -294,7 +294,7 @@ Animations are powered by [@vueuse/motion](https://motion.vueuse.org/).
   </div>
 </div>
 
-<!-- vue script setup scripts can be directly used in markdown, and will only affects current page -->
+<!-- vue script setup scripts can be directly used in markdown, and will only affect the current page -->
 <script setup lang="ts">
 const final = {
   x: 0,
@@ -432,4 +432,4 @@ class: text-center
 
 # Learn More
 
-[Documentations](https://sli.dev) · [GitHub](https://github.com/slidevjs/slidev) · [Showcases](https://sli.dev/showcases.html)
+[Documentation](https://sli.dev) · [GitHub](https://github.com/slidevjs/slidev) · [Showcases](https://sli.dev/showcases.html)

package/dist/chunk-DRWYFCYG.mjs

@@ -1,44 +0,0 @@
-import {
-  ViteSlidevPlugin,
-  mergeViteConfigs
-} from "./chunk-ZATTXN6U.mjs";
-
-// node/commands/server.ts
-import { join } from "node:path";
-import process from "node:process";
-import { createServer as createViteServer, mergeConfig } from "vite";
-async function createServer(options, viteConfig = {}, serverOptions = {}) {
-  process.env.EDITOR = process.env.EDITOR || "code";
-  const config = await mergeViteConfigs(
-    options,
-    viteConfig,
-    {
-      root: options.userRoot,
-      optimizeDeps: {
-        entries: [
-          join(options.clientRoot, "main.ts")
-        ]
-      }
-    },
-    "serve"
-  );
-  const server = await createViteServer(
-    mergeConfig(
-      config,
-      {
-        plugins: [
-          await ViteSlidevPlugin(options, config.slidev || {}, serverOptions)
-        ],
-        define: {
-          // Fixes Vue production mode breaking PDF Export #1245
-          __VUE_PROD_DEVTOOLS__: JSON.stringify(true)
-        }
-      }
-    )
-  );
-  return server;
-}
-
-export {
-  createServer
-};