@slidev/cli 0.45.0 → 0.46.1

package/dist/build-Q7WKYPRH.mjs

@@ -0,0 +1,124 @@
+import {
+  ViteSlidevPlugin,
+  getIndexHtml,
+  mergeViteConfigs
+} from "./chunk-FPUM6TIB.mjs";
+import "./chunk-CTBVOVLQ.mjs";
+import "./chunk-5L3XKTHL.mjs";
+import "./chunk-BXO7ZPPU.mjs";
+
+// node/build.ts
+import { join, resolve } from "node:path";
+import http from "node:http";
+import fs from "fs-extra";
+import { mergeConfig, build as viteBuild } from "vite";
+import connect from "connect";
+import sirv from "sirv";
+import { blue, yellow } from "kolorist";
+async function build(options, viteConfig = {}, args) {
+  const indexPath = resolve(options.userRoot, "index.html");
+  let originalIndexHTML;
+  if (fs.existsSync(indexPath))
+    originalIndexHTML = await fs.readFile(indexPath, "utf-8");
+  await fs.writeFile(indexPath, await getIndexHtml(options), "utf-8");
+  let config = void 0;
+  try {
+    let inlineConfig = await mergeViteConfigs(
+      options,
+      viteConfig,
+      {
+        root: options.userRoot,
+        plugins: [
+          {
+            name: "resolve-config",
+            configResolved(_config) {
+              config = _config;
+            }
+          }
+        ],
+        build: {
+          chunkSizeWarningLimit: 2e3
+        }
+      },
+      "build"
+    );
+    inlineConfig = mergeConfig(
+      inlineConfig,
+      {
+        plugins: [
+          await ViteSlidevPlugin(options, inlineConfig.slidev || {})
+        ]
+      }
+    );
+    await viteBuild(inlineConfig);
+    if (options.data.features.monaco) {
+      if (options.data.config.monaco === "dev") {
+        console.log(yellow("  Monaco is disabled in the build, to enabled it, set `monaco: true` in the frontmatter"));
+      } else {
+        console.log(blue("  building for Monaco...\n"));
+        await viteBuild(
+          await mergeViteConfigs(
+            options,
+            inlineConfig,
+            {
+              root: join(options.clientRoot, "iframes/monaco"),
+              base: `${config.base}iframes/monaco/`,
+              build: {
+                outDir: resolve(config.build.outDir, "iframes/monaco"),
+                // fix for monaco workers
+                // https://github.com/vitejs/vite/issues/1927#issuecomment-805803918
+                rollupOptions: {
+                  output: {
+                    manualChunks: {
+                      jsonWorker: ["monaco-editor/esm/vs/language/json/json.worker"],
+                      cssWorker: ["monaco-editor/esm/vs/language/css/css.worker"],
+                      htmlWorker: ["monaco-editor/esm/vs/language/html/html.worker"],
+                      tsWorker: ["monaco-editor/esm/vs/language/typescript/ts.worker"],
+                      editorWorker: ["monaco-editor/esm/vs/editor/editor.worker"]
+                    }
+                  }
+                }
+              }
+            },
+            "build"
+          )
+        );
+      }
+    }
+  } finally {
+    if (originalIndexHTML != null)
+      await fs.writeFile(indexPath, originalIndexHTML, "utf-8");
+    else
+      await fs.unlink(indexPath);
+  }
+  const outDir = resolve(options.userRoot, config.build.outDir);
+  await fs.copyFile(resolve(outDir, "index.html"), resolve(outDir, "404.html"));
+  const redirectsPath = resolve(outDir, "_redirects");
+  if (!fs.existsSync(redirectsPath))
+    await fs.writeFile(redirectsPath, `${config.base}*    ${config.base}index.html   200
+`, "utf-8");
+  if ([true, "true", "auto"].includes(options.data.config.download)) {
+    const { exportSlides, getExportOptions } = await import("./export-T7HYPK5J.mjs");
+    const port = 12445;
+    const app = connect();
+    const server = http.createServer(app);
+    app.use(
+      config.base,
+      sirv(outDir, {
+        etag: true,
+        single: true,
+        dev: true
+      })
+    );
+    server.listen(port);
+    await exportSlides({
+      port,
+      base: config.base,
+      ...getExportOptions(args, options, outDir, "slidev-exported.pdf")
+    });
+    server.close();
+  }
+}
+export {
+  build
+};

package/dist/{chunk-CYLMMBRG.mjs → chunk-CTBVOVLQ.mjs}

@@ -20,7 +20,7 @@ async function loadSetups(roots, name, arg, initial, merge = true) {
   let returns = initial;
   for (const root of roots) {
     const path = resolve(root, "setup", name);
-    if (await fs.pathExists(path)) {
+    if (fs.existsSync(path)) {
       const { default: setup } = jiti(fileURLToPath(import.meta.url))(path);
       const result = await setup(arg);
       if (result !== null) {

package/dist/{chunk-VHBBQ77F.mjs → chunk-FPUM6TIB.mjs}

@@ -1,6 +1,6 @@
 import {
   loadSetups
-} from "./chunk-CYLMMBRG.mjs";
+} from "./chunk-CTBVOVLQ.mjs";
 import {
   generateGoogleFontsUrl,
   resolveGlobalImportPath,
@@ -8,61 +8,12 @@ import {
   stringifyMarkdownTokens,
   toAtFS
 } from "./chunk-5L3XKTHL.mjs";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-BXO7ZPPU.mjs";
-
-// ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
-var require_fast_deep_equal = __commonJS({
-  "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports, module) {
-    "use strict";
-    module.exports = function equal2(a, b) {
-      if (a === b)
-        return true;
-      if (a && b && typeof a == "object" && typeof b == "object") {
-        if (a.constructor !== b.constructor)
-          return false;
-        var length, i, keys;
-        if (Array.isArray(a)) {
-          length = a.length;
-          if (length != b.length)
-            return false;
-          for (i = length; i-- !== 0; )
-            if (!equal2(a[i], b[i]))
-              return false;
-          return true;
-        }
-        if (a.constructor === RegExp)
-          return a.source === b.source && a.flags === b.flags;
-        if (a.valueOf !== Object.prototype.valueOf)
-          return a.valueOf() === b.valueOf();
-        if (a.toString !== Object.prototype.toString)
-          return a.toString() === b.toString();
-        keys = Object.keys(a);
-        length = keys.length;
-        if (length !== Object.keys(b).length)
-          return false;
-        for (i = length; i-- !== 0; )
-          if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
-            return false;
-        for (i = length; i-- !== 0; ) {
-          var key = keys[i];
-          if (!equal2(a[key], b[key]))
-            return false;
-        }
-        return true;
-      }
-      return a !== a && b !== b;
-    };
-  }
-});
 
 // node/common.ts
 import { existsSync, promises as fs } from "node:fs";
 import { join } from "node:path";
 import { uniq } from "@antfu/utils";
-import { loadConfigFromFile, mergeConfig } from "vite";
+import { loadConfigFromFile, mergeConfig, resolveConfig } from "vite";
 async function getIndexHtml({ clientRoot, themeRoots, addonRoots, data, userRoot }) {
   let main = await fs.readFile(join(clientRoot, "index.html"), "utf-8");
   let head = "";
@@ -91,7 +42,7 @@ ${(index.match(/<body>([\s\S]*?)<\/body>/im)?.[1] || "").trim()}`;
   main = main.replace("__ENTRY__", toAtFS(join(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
   return main;
 }
-async function mergeViteConfigs({ addonRoots, themeRoots }, viteConfig, config, command) {
+async function mergeViteConfigs({ addonRoots, themeRoots, entry }, viteConfig, config, command) {
   const configEnv = {
     mode: "development",
     command
@@ -108,7 +59,10 @@ async function mergeViteConfigs({ addonRoots, themeRoots }, viteConfig, config,
       continue;
     config = mergeConfig(config, viteConfig2.config);
   }
-  return mergeConfig(viteConfig, config);
+  config = mergeConfig(config, viteConfig);
+  const localConfig = await resolveConfig({}, command, entry);
+  config = mergeConfig(config, { slidev: localConfig.slidev || {} });
+  return config;
 }
 
 // node/plugins/preset.ts
@@ -182,13 +136,13 @@ import { uniq as uniq2 } from "@antfu/utils";
 
 // ../client/package.json
 var dependencies = {
-  "@antfu/utils": "^0.7.6",
+  "@antfu/utils": "^0.7.7",
   "@slidev/parser": "workspace:*",
   "@slidev/types": "workspace:*",
-  "@unhead/vue": "^1.8.8",
+  "@unhead/vue": "^1.8.9",
   "@unocss/reset": "^0.58.0",
-  "@vueuse/core": "^10.6.1",
-  "@vueuse/math": "^10.6.1",
+  "@vueuse/core": "^10.7.0",
+  "@vueuse/math": "^10.7.0",
   "@vueuse/motion": "^2.0.0",
   codemirror: "^5.65.5",
   defu: "^6.1.3",
@@ -201,12 +155,12 @@ var dependencies = {
   mermaid: "^10.6.1",
   "monaco-editor": "^0.37.1",
   nanoid: "^5.0.4",
-  prettier: "^3.1.0",
+  prettier: "^3.1.1",
   recordrtc: "^5.6.2",
   resolve: "^1.22.8",
   unocss: "^0.58.0",
   "vite-plugin-windicss": "^1.9.2",
-  vue: "^3.3.9",
+  vue: "^3.3.12",
   "vue-router": "^4.2.5",
   "vue-starport": "^0.4.0",
   windicss: "^3.5.6"
@@ -363,7 +317,6 @@ function getDefine(options) {
 }
 
 // node/plugins/loaders.ts
-var import_fast_deep_equal = __toESM(require_fast_deep_equal());
 import { basename as basename2, join as join5 } from "node:path";
 import process from "node:process";
 import { isString, notNullish, objectMap, range, slash, uniq as uniq3 } from "@antfu/utils";
@@ -373,6 +326,7 @@ import Markdown from "markdown-it";
 import { bold, gray, red, yellow } from "kolorist";
 import mila from "markdown-it-link-attributes";
 import * as parser from "@slidev/parser/fs";
+import equal from "fast-deep-equal";
 var regexId = /^\/\@slidev\/slide\/(\d+)\.(md|json)(?:\?import)?$/;
 var regexIdQuery = /(\d+?)\.(md|json|frontmatter)$/;
 var vueContextImports = [
@@ -391,13 +345,13 @@ var vueContextImports = [
   "const $renderContext = _vueInject(_injectionRenderContext)"
 ];
 function getBodyJson(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let body = "";
     req.on("data", (chunk) => body += chunk);
     req.on("error", reject);
     req.on("end", () => {
       try {
-        resolve3(JSON.parse(body) || {});
+        resolve4(JSON.parse(body) || {});
       } catch (e) {
         reject(e);
       }
@@ -467,13 +421,13 @@ function createSlidesLoader({ data, entry, clientRoot, themeRoots, addonRoots, u
           moduleIds.add("/@slidev/routes");
           range(newData.slides.length).map((i) => hmrPages.add(i));
         }
-        if (!(0, import_fast_deep_equal.default)(data.headmatter.defaults, newData.headmatter.defaults)) {
+        if (!equal(data.headmatter.defaults, newData.headmatter.defaults)) {
           moduleIds.add("/@slidev/routes");
           range(data.slides.length).map((i) => hmrPages.add(i));
         }
-        if (!(0, import_fast_deep_equal.default)(data.config, newData.config))
+        if (!equal(data.config, newData.config))
           moduleIds.add("/@slidev/configs");
-        if (!(0, import_fast_deep_equal.default)(data.features, newData.features)) {
+        if (!equal(data.features, newData.features)) {
           setTimeout(() => {
             ctx.server.ws.send({ type: "full-reload" });
           }, 1);
@@ -482,7 +436,7 @@ function createSlidesLoader({ data, entry, clientRoot, themeRoots, addonRoots, u
         for (let i = 0; i < length; i++) {
           const a = data.slides[i];
           const b = newData.slides[i];
-          if (a?.content.trim() === b?.content.trim() && a?.title?.trim() === b?.title?.trim() && a?.note === b?.note && (0, import_fast_deep_equal.default)(a.frontmatter, b.frontmatter))
+          if (a?.content.trim() === b?.content.trim() && a?.title?.trim() === b?.title?.trim() && a?.note === b?.note && equal(a.frontmatter, b.frontmatter))
             continue;
           ctx.server.ws.send({
             type: "custom",
@@ -817,6 +771,8 @@ defineProps<{ no: number | string }>()`);
     }
     if (data.features.katex)
       imports.push(`import "${toAtFS(resolveImportPath("katex/dist/katex.min.css", true))}"`);
+    if (data.config.highlighter === "shikiji")
+      imports.push(`import "${toAtFS(resolveImportPath("shikiji-twoslash/style-rich.css", true))}"`);
     if (data.config.css === "unocss") {
       imports.unshift(
         'import "@unocss/reset/tailwind.css"',
@@ -1036,14 +992,146 @@ function createClientSetupPlugin({ clientRoot, themeRoots, addonRoots, userRoot
 }
 
 // node/plugins/markdown.ts
+import { resolve as resolve3 } from "node:path";
 import Markdown2 from "unplugin-vue-markdown/vite";
 import * as base64 from "js-base64";
 import { slash as slash4 } from "@antfu/utils";
 import mila2 from "markdown-it-link-attributes";
 import mif from "markdown-it-footnote";
-import { taskLists } from "@hedgedoc/markdown-it-plugins";
+
+// ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.0.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/image-size/specialCharacters.js
+var SpecialCharacters;
+(function(SpecialCharacters2) {
+  SpecialCharacters2[SpecialCharacters2["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
+  SpecialCharacters2[SpecialCharacters2["OPENING_BRACKET"] = 91] = "OPENING_BRACKET";
+  SpecialCharacters2[SpecialCharacters2["OPENING_PARENTHESIS"] = 40] = "OPENING_PARENTHESIS";
+  SpecialCharacters2[SpecialCharacters2["WHITESPACE"] = 32] = "WHITESPACE";
+  SpecialCharacters2[SpecialCharacters2["NEW_LINE"] = 10] = "NEW_LINE";
+  SpecialCharacters2[SpecialCharacters2["EQUALS"] = 61] = "EQUALS";
+  SpecialCharacters2[SpecialCharacters2["LOWER_CASE_X"] = 120] = "LOWER_CASE_X";
+  SpecialCharacters2[SpecialCharacters2["NUMBER_ZERO"] = 48] = "NUMBER_ZERO";
+  SpecialCharacters2[SpecialCharacters2["NUMBER_NINE"] = 57] = "NUMBER_NINE";
+  SpecialCharacters2[SpecialCharacters2["PERCENTAGE"] = 37] = "PERCENTAGE";
+  SpecialCharacters2[SpecialCharacters2["CLOSING_PARENTHESIS"] = 41] = "CLOSING_PARENTHESIS";
+})(SpecialCharacters || (SpecialCharacters = {}));
+
+// ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.0.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/task-lists/index.js
+import Token from "markdown-it/lib/token.mjs";
+var checkboxRegex = /^ *\[([\sx])] /i;
+function taskLists(md2, options = { enabled: false, label: false, lineNumber: false }) {
+  md2.core.ruler.after("inline", "task-lists", (state) => processToken(state, options));
+  md2.renderer.rules.taskListItemCheckbox = (tokens) => {
+    const token = tokens[0];
+    const checkedAttribute = token.attrGet("checked") ? 'checked="" ' : "";
+    const disabledAttribute = token.attrGet("disabled") ? 'disabled="" ' : "";
+    const line = token.attrGet("line");
+    const idAttribute = `id="${token.attrGet("id")}" `;
+    const dataLineAttribute = line && options.lineNumber ? `data-line="${line}" ` : "";
+    return `<input class="task-list-item-checkbox" type="checkbox" ${checkedAttribute}${disabledAttribute}${dataLineAttribute}${idAttribute}/>`;
+  };
+  md2.renderer.rules.taskListItemLabel_close = () => {
+    return "</label>";
+  };
+  md2.renderer.rules.taskListItemLabel_open = (tokens) => {
+    const token = tokens[0];
+    const id = token.attrGet("id");
+    return `<label for="${id}">`;
+  };
+}
+function processToken(state, options) {
+  const allTokens = state.tokens;
+  for (let i = 2; i < allTokens.length; i++) {
+    if (!isTodoItem(allTokens, i)) {
+      continue;
+    }
+    todoify(allTokens[i], options);
+    allTokens[i - 2].attrJoin("class", `task-list-item ${options.enabled ? " enabled" : ""}`);
+    const parentToken = findParentToken(allTokens, i - 2);
+    if (parentToken) {
+      const classes = parentToken.attrGet("class") ?? "";
+      if (!classes.match(/(^| )contains-task-list/)) {
+        parentToken.attrJoin("class", "contains-task-list");
+      }
+    }
+  }
+  return false;
+}
+function findParentToken(tokens, index) {
+  const targetLevel = tokens[index].level - 1;
+  for (let currentTokenIndex = index - 1; currentTokenIndex >= 0; currentTokenIndex--) {
+    if (tokens[currentTokenIndex].level === targetLevel) {
+      return tokens[currentTokenIndex];
+    }
+  }
+  return void 0;
+}
+function isTodoItem(tokens, index) {
+  return isInline(tokens[index]) && isParagraph(tokens[index - 1]) && isListItem(tokens[index - 2]) && startsWithTodoMarkdown(tokens[index]);
+}
+function todoify(token, options) {
+  if (token.children == null) {
+    return;
+  }
+  const id = generateIdForToken(token);
+  token.children.splice(0, 0, createCheckboxToken(token, options.enabled, id));
+  token.children[1].content = token.children[1].content.replace(checkboxRegex, "");
+  if (options.label) {
+    token.children.splice(1, 0, createLabelBeginToken(id));
+    token.children.push(createLabelEndToken());
+  }
+}
+function generateIdForToken(token) {
+  if (token.map) {
+    return `task-item-${token.map[0]}`;
+  } else {
+    return `task-item-${Math.ceil(Math.random() * (1e4 * 1e3) - 1e3)}`;
+  }
+}
+function createCheckboxToken(token, enabled, id) {
+  const checkbox = new Token("taskListItemCheckbox", "", 0);
+  if (!enabled) {
+    checkbox.attrSet("disabled", "true");
+  }
+  if (token.map) {
+    checkbox.attrSet("line", token.map[0].toString());
+  }
+  checkbox.attrSet("id", id);
+  const checkboxRegexResult = checkboxRegex.exec(token.content);
+  const isChecked = checkboxRegexResult?.[1].toLowerCase() === "x";
+  if (isChecked) {
+    checkbox.attrSet("checked", "true");
+  }
+  return checkbox;
+}
+function createLabelBeginToken(id) {
+  const labelBeginToken = new Token("taskListItemLabel_open", "", 1);
+  labelBeginToken.attrSet("id", id);
+  return labelBeginToken;
+}
+function createLabelEndToken() {
+  return new Token("taskListItemLabel_close", "", -1);
+}
+function isInline(token) {
+  return token.type === "inline";
+}
+function isParagraph(token) {
+  return token.type === "paragraph_open";
+}
+function isListItem(token) {
+  return token.type === "list_item_open";
+}
+function startsWithTodoMarkdown(token) {
+  return checkboxRegex.test(token.content);
+}
+
+// ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.0.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/toc/plugin.js
+import { Optional } from "@mrdrogdrog/optional";
+
+// node/plugins/markdown.ts
 import { encode as encode2 } from "plantuml-encoder";
 import Mdc from "markdown-it-mdc";
+import { addClassToHast } from "shikiji";
+import fs6 from "fs-extra";
 
 // node/plugins/markdown-it-katex.ts
 import katex from "katex";
@@ -1364,6 +1452,34 @@ async function createMarkdownPlugin({ data: { config }, roots, mode, entry }, {
     const { langs, themes } = resolveShikiOptions(shikiOptions);
     shikiOptions.highlighter = await Shiki.getHighlighter({ themes, langs });
     setups.push((md2) => md2.use(markdown_it_shiki_default, shikiOptions));
+  } else if (config.highlighter === "shikiji") {
+    const MarkdownItShikiji = await import("markdown-it-shikiji").then((r) => r.default);
+    const { transformerTwoSlash, rendererRich } = await import("shikiji-twoslash");
+    const options = await loadShikijiSetups(roots);
+    const plugin = await MarkdownItShikiji({
+      ...options,
+      transformers: [
+        ...options.transformers || [],
+        transformerTwoSlash({
+          explicitTrigger: true,
+          renderer: rendererRich(),
+          twoslashOptions: {
+            defaultOptions: {
+              noErrorValidation: true
+            }
+          }
+        }),
+        {
+          pre(pre) {
+            addClassToHast(pre, "slidev-code shikiji");
+          },
+          postprocess(code) {
+            return escapeVueInCode(code);
+          }
+        }
+      ]
+    });
+    setups.push((md2) => md2.use(plugin));
   } else {
     setups.push((md2) => md2.use(markdownItPrism));
   }
@@ -1452,7 +1568,7 @@ function transformSlotSugar(md2) {
   lines.forEach((line, idx) => {
     if (isLineInsideCodeblocks(idx))
       return;
-    const match = line.trimEnd().match(/^::\s*(\w+)\s*::$/);
+    const match = line.trimEnd().match(/^::\s*([\w\.\-\:]+)\s*::$/);
     if (match) {
       lines[idx] = `${prevSlot ? "\n\n</template>\n" : "\n"}<template v-slot:${match[1]}="slotProps">
 `;
@@ -1464,14 +1580,14 @@ function transformSlotSugar(md2) {
   return lines.join("\n");
 }
 function transformHighlighter(md2) {
-  return md2.replace(/^```(\w+?)(?:\s*{([\d\w*,\|-]+)}\s*?({.*?})?\s*?)?\n([\s\S]+?)^```/mg, (full, lang = "", rangeStr = "", options = "", code) => {
+  return md2.replace(/^```(\w+?)(?:\s*{([\d\w*,\|-]+)}\s*?({.*?})?(.*?))?\n([\s\S]+?)^```/mg, (full, lang = "", rangeStr = "", options = "", attrs = "", code) => {
     const ranges = rangeStr.split(/\|/g).map((i) => i.trim());
     code = code.trimEnd();
     options = options.trim() || "{}";
     return `
 <CodeBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>
 
-\`\`\`${lang}
+\`\`\`${lang}${attrs}
 ${code}
 \`\`\`
 
@@ -1532,6 +1648,25 @@ function transformPlantUml(md2, server) {
 function escapeVueInCode(md2) {
   return md2.replace(/{{(.*?)}}/g, "&lbrace;&lbrace;$1&rbrace;&rbrace;");
 }
+async function loadShikijiSetups(roots) {
+  const anyShikiji = roots.some((root) => fs6.existsSync(resolve3(root, "setup", "shikiji.ts")));
+  const result = anyShikiji ? await loadSetups(roots, "shikiji.ts", void 0, {}, false) : await loadSetups(roots, "shiki.ts", await import("shiki"), {}, false);
+  if ("theme" in result && "themes" in result)
+    delete result.theme;
+  if (result.theme && typeof result.theme !== "string") {
+    result.themes = result.theme;
+    delete result.theme;
+  }
+  if (!result.theme && !result.themes) {
+    result.themes = {
+      dark: "vitesse-dark",
+      light: "vitesse-light"
+    };
+  }
+  if (result.themes)
+    result.defaultColor = false;
+  return result;
+}
 
 // node/plugins/patchTransform.ts
 import { objectEntries } from "@antfu/utils";
@@ -1697,7 +1832,7 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
       dev: true,
       build: true
     })) : null,
-    config.css === "none" ? null : config.css === "windicss" ? import("./windicss-SDUK26CZ.mjs").then((r) => r.createWindiCSSPlugin(options, pluginOptions)) : import("./unocss-GHP27KVT.mjs").then((r) => r.createUnocssPlugin(options, pluginOptions))
+    config.css === "none" ? null : config.css === "windicss" ? import("./windicss-V4JJMSQI.mjs").then((r) => r.createWindiCSSPlugin(options, pluginOptions)) : import("./unocss-6IVIFJMZ.mjs").then((r) => r.createUnocssPlugin(options, pluginOptions))
   ];
   return (await Promise.all(plugins)).flat().filter(notNullish2);
 }
@@ -1705,6 +1840,5 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
 export {
   getIndexHtml,
   mergeViteConfigs,
-  require_fast_deep_equal,
   ViteSlidevPlugin
 };

package/dist/{chunk-A7WCFT3T.mjs → chunk-GLZC72RJ.mjs}

@@ -1,6 +1,6 @@
 import {
   loadSetups
-} from "./chunk-CYLMMBRG.mjs";
+} from "./chunk-CTBVOVLQ.mjs";
 import {
   resolveImportPath
 } from "./chunk-5L3XKTHL.mjs";

package/dist/{chunk-G3XS4CNO.mjs → chunk-RRC2SQPF.mjs}

@@ -1,7 +1,7 @@
 import {
   ViteSlidevPlugin,
   mergeViteConfigs
-} from "./chunk-VHBBQ77F.mjs";
+} from "./chunk-FPUM6TIB.mjs";
 import {
   packageExists,
   resolveImportPath
@@ -2490,27 +2490,30 @@ var require_semver2 = __commonJS({
 // node/server.ts
 import { join } from "node:path";
 import process2 from "node:process";
-import { createServer as createViteServer, resolveConfig } from "vite";
+import { createServer as createViteServer, mergeConfig } from "vite";
 async function createServer(options2, viteConfig = {}, serverOptions = {}) {
-  const rawConfig = await resolveConfig({}, "serve", options2.entry);
-  const pluginOptions = rawConfig.slidev || {};
   process2.env.EDITOR = process2.env.EDITOR || "code";
+  const config2 = await mergeViteConfigs(
+    options2,
+    viteConfig,
+    {
+      root: options2.userRoot,
+      optimizeDeps: {
+        entries: [
+          join(options2.clientRoot, "main.ts")
+        ]
+      }
+    },
+    "serve"
+  );
   const server = await createViteServer(
-    await mergeViteConfigs(
-      options2,
-      viteConfig,
+    mergeConfig(
+      config2,
       {
-        root: options2.userRoot,
-        optimizeDeps: {
-          entries: [
-            join(options2.clientRoot, "main.ts")
-          ]
-        },
         plugins: [
-          await ViteSlidevPlugin(options2, pluginOptions, serverOptions)
+          await ViteSlidevPlugin(options2, config2.slidev || {}, serverOptions)
         ]
-      },
-      "serve"
+      }
     )
   );
   return server;
@@ -2520,7 +2523,7 @@ async function createServer(options2, viteConfig = {}, serverOptions = {}) {
 import * as parser from "@slidev/parser/fs";
 
 // package.json
-var version = "0.45.0";
+var version = "0.46.1";
 
 // node/themes.ts
 import prompts2 from "prompts";