@slidev/cli 0.49.29 → 0.50.0-beta.10

package/dist/{chunk-YP37OZJY.js → chunk-Q74EQR62.js}

@@ -1,8 +1,3 @@
-import {
-  escapeVueInCode,
-  getCodeBlocks,
-  normalizeRangeStr
-} from "./chunk-6DS3IPOB.js";
 import {
   createResolver,
   getRoots,
@@ -11,10 +6,79 @@ import {
   resolveImportPath,
   resolveImportUrl,
   toAtFS
-} from "./chunk-HOVIRHCR.js";
+} from "./chunk-UNQ5DBLZ.js";
+
+// package.json
+var version = "0.50.0-beta.10";
+
+// node/integrations/themes.ts
+import { join } from "node:path";
+import fs 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 = join(root, "package.json");
+  if (!fs.existsSync(path4))
+    return {};
+  const { slidev = {}, engines = {} } = await fs.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/parser.ts
+import * as parser from "@slidev/parser/fs";
+
+// node/options.ts
+import path3 from "node:path";
+import { uniq as uniq5 } from "@antfu/utils";
+import Debug from "debug";
+import fg4 from "fast-glob";
+import mm from "micromatch";
+
+// node/integrations/addons.ts
+import { resolve } from "node:path";
+import fs2 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 fs2.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/setups/indexHtml.ts
+import { existsSync as existsSync8, readFileSync as readFileSync2 } from "node:fs";
+import { join as join13 } from "node:path";
+import { slash as slash4 } from "@antfu/utils";
+import { white, yellow as yellow2 } from "kolorist";
+import { escapeHtml } from "markdown-it/lib/common/utils.mjs";
 
 // node/commands/shared.ts
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { join as join12 } from "node:path";
 import MarkdownIt from "markdown-it";
 import { loadConfigFromFile, mergeConfig as mergeConfig2 } from "vite";
@@ -45,12 +109,12 @@ function MarkdownItLink(md) {
 
 // node/utils.ts
 import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
 import YAML from "yaml";
-import createJiti from "jiti";
 var jiti;
 function loadModule(absolutePath) {
   jiti ??= createJiti(fileURLToPath(import.meta.url));
-  return jiti(absolutePath);
+  return jiti.import(absolutePath);
 }
 function stringifyMarkdownTokens(tokens) {
   return tokens.map((token) => token.children?.filter((t) => ["text", "code_inline"].includes(t.type) && !t.content.match(/^\s*$/)).map((t) => t.content.trim()).join(" ")).filter(Boolean).join(" ");
@@ -94,13 +158,13 @@ function updateFrontmatterPatch(slide, frontmatter) {
   }
 }
 function getBodyJson(req) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let body = "";
     req.on("data", (chunk) => body += chunk);
     req.on("error", reject);
     req.on("end", () => {
       try {
-        resolve8(JSON.parse(body) || {});
+        resolve9(JSON.parse(body) || {});
       } catch (e) {
         reject(e);
       }
@@ -110,13 +174,122 @@ function getBodyJson(req) {
 
 // node/vite/compilerFlagsVue.ts
 import { objectEntries } from "@antfu/utils";
+function createVueCompilerFlagsPlugin(options) {
+  const define = objectEntries(options.utils.define);
+  return {
+    name: "slidev:flags",
+    enforce: "pre",
+    transform(code, id) {
+      if (!id.match(/\.vue($|\?)/) && !id.includes("?vue&"))
+        return;
+      const original = code;
+      define.forEach(([from, to]) => {
+        code = code.replaceAll(from, to);
+      });
+      if (original !== code)
+        return code;
+    }
+  };
+}
+
+// node/vite/components.ts
+import { join as join2 } from "node:path";
+import IconsResolver from "unplugin-icons/resolver";
+import Components from "unplugin-vue-components/vite";
+function createComponentsPlugin({ clientRoot, roots }, pluginOptions) {
+  return Components({
+    extensions: ["vue", "md", "js", "ts", "jsx", "tsx"],
+    dirs: [
+      join2(clientRoot, "builtin"),
+      ...roots.map((i) => join2(i, "components"))
+    ],
+    include: [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/, /\.md$/, /\.md\?vue/],
+    exclude: [],
+    resolvers: [
+      IconsResolver({
+        prefix: "",
+        customCollections: Object.keys(pluginOptions.icons?.customCollections || [])
+      })
+    ],
+    dts: false,
+    ...pluginOptions.components
+  });
+}
+
+// node/vite/common.ts
+var regexSlideReqPath = /^\/__slidev\/slides\/(\d+)\.json$/;
+var regexSlideFacadeId = /^\/@slidev\/slides\/(\d+)\/(md|frontmatter)($|\?)/;
+var regexSlideSourceId = /__slidev_(\d+)\.(md|frontmatter)$/;
+var templateInjectionMarker = "/* @slidev-injection */";
+var templateImportContextUtils = `import { useSlideContext as _useSlideContext, frontmatterToProps as _frontmatterToProps } from "@slidev/client/context.ts"`;
+var templateInitContext = `const { $slidev, $nav, $clicksContext, $clicks, $page, $renderContext, $frontmatter } = _useSlideContext()`;
+
+// node/vite/contextInjection.ts
+function createContextInjectionPlugin() {
+  return {
+    name: "slidev:context-injection",
+    async transform(code, id) {
+      if (!id.endsWith(".vue") || id.includes("/@slidev/client/") || id.includes("/packages/client/"))
+        return;
+      if (code.includes(templateInjectionMarker) || code.includes("useSlideContext()"))
+        return code;
+      const imports = [
+        templateImportContextUtils,
+        templateInitContext,
+        templateInjectionMarker
+      ];
+      const matchScript = code.match(/<script((?!setup).)*(setup)?.*>/);
+      if (matchScript && matchScript[2]) {
+        return code.replace(/(<script.*>)/g, `$1
+${imports.join("\n")}
+`);
+      } else if (matchScript && !matchScript[2]) {
+        const matchExport = code.match(/export\s+default\s+\{/);
+        if (matchExport) {
+          const exportIndex = (matchExport.index || 0) + matchExport[0].length;
+          let component = code.slice(exportIndex);
+          component = component.slice(0, component.indexOf("</script>"));
+          const scriptIndex = (matchScript.index || 0) + matchScript[0].length;
+          const provideImport = '\nimport { injectionSlidevContext } from "@slidev/client/constants.ts"\n';
+          code = `${code.slice(0, scriptIndex)}${provideImport}${code.slice(scriptIndex)}`;
+          let injectIndex = exportIndex + provideImport.length;
+          let injectObject = "$slidev: { from: injectionSlidevContext },";
+          const matchInject = component.match(/.*inject\s*:\s*([[{])/);
+          if (matchInject) {
+            injectIndex += (matchInject.index || 0) + matchInject[0].length;
+            if (matchInject[1] === "[") {
+              let injects = component.slice((matchInject.index || 0) + matchInject[0].length);
+              const injectEndIndex = injects.indexOf("]");
+              injects = injects.slice(0, injectEndIndex);
+              injectObject += injects.split(",").map((inject) => `${inject}: {from: ${inject}}`).join(",");
+              return `${code.slice(0, injectIndex - 1)}{
+${injectObject}
+}${code.slice(injectIndex + injectEndIndex + 1)}`;
+            } else {
+              return `${code.slice(0, injectIndex)}
+${injectObject}
+${code.slice(injectIndex)}`;
+            }
+          }
+          return `${code.slice(0, injectIndex)}
+inject: { ${injectObject} },
+${code.slice(injectIndex)}`;
+        }
+      }
+      return `<script setup>
+${imports.join("\n")}
+</script>
+${code}`;
+    }
+  };
+}
 
 // node/vite/extendConfig.ts
-import { join } from "node:path";
+import { join as join3 } from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-import { mergeConfig } from "vite";
 import { slash, uniq } from "@antfu/utils";
 import { createResolve } from "mlly";
+import { mergeConfig } from "vite";
 var INCLUDE_GLOBAL = [
   "@typescript/ata",
   "file-saver",
@@ -124,7 +297,8 @@ var INCLUDE_GLOBAL = [
   "prettier",
   "recordrtc",
   "typescript",
-  "yaml"
+  "yaml",
+  "html-to-image"
 ];
 var INCLUDE_LOCAL = INCLUDE_GLOBAL.map((i) => `@slidev/cli > @slidev/client > ${i}`);
 var EXCLUDE_GLOBAL = [
@@ -173,7 +347,7 @@ function createConfigPlugin(options) {
     name: "slidev:config",
     async config(config) {
       const injection = {
-        define: getDefine(options),
+        define: options.utils.define,
         resolve: {
           alias: [
             {
@@ -226,7 +400,7 @@ function createConfigPlugin(options) {
             ])
           }
         },
-        publicDir: join(options.userRoot, "public"),
+        publicDir: join3(options.userRoot, "public"),
         build: {
           rollupOptions: {
             output: {
@@ -253,21 +427,18 @@ function createConfigPlugin(options) {
               }
             }
           }
-        }
+        },
+        cacheDir: isInstalledGlobally.value ? join3(options.cliRoot, "node_modules/.vite") : void 0
       };
       function isSlidevClient(id) {
         return id.includes("/@slidev/") || id.includes("/slidev/packages/client/") || id.includes("/@vueuse/");
       }
-      if (isInstalledGlobally.value) {
-        injection.cacheDir = join(options.cliRoot, "node_modules/.vite");
-        injection.root = options.cliRoot;
-      }
       return mergeConfig(injection, config);
     },
     configureServer(server) {
       return () => {
         server.middlewares.use(async (req, res, next) => {
-          if (req.url.endsWith(".html")) {
+          if (req.url === "/index.html") {
             res.setHeader("Content-Type", "text/html");
             res.statusCode = 200;
             res.end(options.utils.indexHtml);
@@ -279,174 +450,46 @@ function createConfigPlugin(options) {
     }
   };
 }
-function getDefine(options) {
+
+// node/vite/hmrPatch.ts
+function createHmrPatchPlugin() {
   return {
-    __DEV__: options.mode === "dev" ? "true" : "false",
-    __SLIDEV_CLIENT_ROOT__: JSON.stringify(toAtFS(options.clientRoot)),
-    __SLIDEV_HASH_ROUTE__: JSON.stringify(options.data.config.routerMode === "hash"),
-    __SLIDEV_FEATURE_DRAWINGS__: JSON.stringify(options.data.config.drawings.enabled === true || options.data.config.drawings.enabled === options.mode),
-    __SLIDEV_FEATURE_EDITOR__: JSON.stringify(options.mode === "dev" && options.data.config.editor !== false),
-    __SLIDEV_FEATURE_DRAWINGS_PERSIST__: JSON.stringify(!!options.data.config.drawings.persist === true),
-    __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"
+    name: "slidev:hmr-patch",
+    transform(code, id) {
+      if (!id.match(regexSlideSourceId))
+        return;
+      return code.replace("if (_rerender_only)", "if (false)");
+    }
   };
 }
 
-// node/vite/compilerFlagsVue.ts
-function createVueCompilerFlagsPlugin(options) {
-  const define = objectEntries(getDefine(options));
-  return [
-    {
-      name: "slidev:flags",
-      enforce: "pre",
-      transform(code, id) {
-        if (id.match(/\.vue($|\?)/)) {
-          const original = code;
-          define.forEach(([from, to]) => {
-            code = code.replace(new RegExp(from, "g"), to);
-          });
-          if (original !== code)
-            return code;
-        }
-      }
-    }
-  ];
+// node/vite/icons.ts
+import Icons from "unplugin-icons/vite";
+function createIconsPlugin(options, pluginOptions) {
+  return Icons({
+    defaultClass: "slidev-icon",
+    collectionsNodeResolvePath: options.utils.iconsResolvePath,
+    ...pluginOptions.icons
+  });
 }
 
-// node/vite/components.ts
-import { join as join2 } from "node:path";
-import IconsResolver from "unplugin-icons/resolver";
-import Components from "unplugin-vue-components/vite";
-function createComponentsPlugin({ clientRoot, roots }, pluginOptions) {
-  return Components({
-    extensions: ["vue", "md", "js", "ts", "jsx", "tsx"],
-    dirs: [
-      join2(clientRoot, "builtin"),
-      ...roots.map((i) => join2(i, "components"))
-    ],
-    include: [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/, /\.md$/, /\.md\?vue/],
-    exclude: [],
-    resolvers: [
-      IconsResolver({
-        prefix: "",
-        customCollections: Object.keys(pluginOptions.icons?.customCollections || [])
-      })
-    ],
-    dts: false,
-    ...pluginOptions.components
+// node/vite/inspect.ts
+async function createInspectPlugin(options, pluginOptions) {
+  if (!options.inspect)
+    return;
+  const { default: PluginInspect } = await import("vite-plugin-inspect");
+  return PluginInspect({
+    dev: true,
+    build: true,
+    ...pluginOptions.inspect
   });
 }
 
-// node/vite/common.ts
-var regexSlideReqPath = /^\/__slidev\/slides\/(\d+)\.json$/;
-var regexSlideFacadeId = /^\/@slidev\/slides\/(\d+)\/(md|frontmatter)($|\?)/;
-var regexSlideSourceId = /__slidev_(\d+)\.(md|frontmatter)$/;
-var templateInjectionMarker = "/* @slidev-injection */";
-var templateImportContextUtils = `import { useSlideContext as _useSlideContext, frontmatterToProps as _frontmatterToProps } from "@slidev/client/context.ts"`;
-var templateInitContext = `const { $slidev, $nav, $clicksContext, $clicks, $page, $renderContext, $frontmatter } = _useSlideContext()`;
-
-// node/vite/contextInjection.ts
-function createContextInjectionPlugin() {
+// node/vite/layoutWrapper.ts
+import { bold, gray, red, yellow } from "kolorist";
+function createLayoutWrapperPlugin({ data, utils }) {
   return {
-    name: "slidev:context-injection",
-    async transform(code, id) {
-      if (!id.endsWith(".vue") || id.includes("/@slidev/client/") || id.includes("/packages/client/"))
-        return;
-      if (code.includes(templateInjectionMarker) || code.includes("useSlideContext()"))
-        return code;
-      const imports = [
-        templateImportContextUtils,
-        templateInitContext,
-        templateInjectionMarker
-      ];
-      const matchScript = code.match(/<script((?!setup).)*(setup)?.*>/);
-      if (matchScript && matchScript[2]) {
-        return code.replace(/(<script.*>)/g, `$1
-${imports.join("\n")}
-`);
-      } else if (matchScript && !matchScript[2]) {
-        const matchExport = code.match(/export\s+default\s+\{/);
-        if (matchExport) {
-          const exportIndex = (matchExport.index || 0) + matchExport[0].length;
-          let component = code.slice(exportIndex);
-          component = component.slice(0, component.indexOf("</script>"));
-          const scriptIndex = (matchScript.index || 0) + matchScript[0].length;
-          const provideImport = '\nimport { injectionSlidevContext } from "@slidev/client/constants.ts"\n';
-          code = `${code.slice(0, scriptIndex)}${provideImport}${code.slice(scriptIndex)}`;
-          let injectIndex = exportIndex + provideImport.length;
-          let injectObject = "$slidev: { from: injectionSlidevContext },";
-          const matchInject = component.match(/.*inject\s*:\s*([[{])/);
-          if (matchInject) {
-            injectIndex += (matchInject.index || 0) + matchInject[0].length;
-            if (matchInject[1] === "[") {
-              let injects = component.slice((matchInject.index || 0) + matchInject[0].length);
-              const injectEndIndex = injects.indexOf("]");
-              injects = injects.slice(0, injectEndIndex);
-              injectObject += injects.split(",").map((inject) => `${inject}: {from: ${inject}}`).join(",");
-              return `${code.slice(0, injectIndex - 1)}{
-${injectObject}
-}${code.slice(injectIndex + injectEndIndex + 1)}`;
-            } else {
-              return `${code.slice(0, injectIndex)}
-${injectObject}
-${code.slice(injectIndex)}`;
-            }
-          }
-          return `${code.slice(0, injectIndex)}
-inject: { ${injectObject} },
-${code.slice(injectIndex)}`;
-        }
-      }
-      return `<script setup>
-${imports.join("\n")}
-</script>
-${code}`;
-    }
-  };
-}
-
-// node/vite/hmrPatch.ts
-function createHmrPatchPlugin() {
-  return {
-    name: "slidev:slide-transform:post",
-    transform(code, id) {
-      if (!id.match(regexSlideSourceId))
-        return;
-      return code.replace("if (_rerender_only)", "if (false)");
-    }
-  };
-}
-
-// node/vite/icons.ts
-import Icons from "unplugin-icons/vite";
-function createIconsPlugin(options, pluginOptions) {
-  return Icons({
-    defaultClass: "slidev-icon",
-    collectionsNodeResolvePath: options.utils.iconsResolvePath,
-    ...pluginOptions.icons
-  });
-}
-
-// node/vite/inspect.ts
-async function createInspectPlugin(options, pluginOptions) {
-  if (!options.inspect)
-    return;
-  const { default: PluginInspect } = await import("vite-plugin-inspect");
-  return PluginInspect({
-    dev: true,
-    build: true,
-    ...pluginOptions.inspect
-  });
-}
-
-// node/vite/layoutWrapper.ts
-import { bold, gray, red, yellow } from "kolorist";
-function createLayoutWrapperPlugin({ data, utils }) {
-  return {
-    name: "slidev:layout-wrapper",
+    name: "slidev:layout-wrapper",
     async transform(code, id) {
       const match = id.match(regexSlideSourceId);
       if (!match)
@@ -455,7 +498,7 @@ function createLayoutWrapperPlugin({ data, utils }) {
       if (type !== "md")
         return;
       const index = +no - 1;
-      const layouts = await utils.getLayouts();
+      const layouts = utils.getLayouts();
       const rawLayoutName = data.slides[index]?.frontmatter?.layout ?? data.slides[0]?.frontmatter?.defaults?.layout;
       let layoutName = rawLayoutName || (index === 0 ? "cover" : "default");
       if (!layouts[layoutName]) {
@@ -541,14 +584,14 @@ console.warn('/@slidev/titles.md is deprecated, import from #slidev/title-render
 
 // node/virtual/global-layers.ts
 import { existsSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } 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) => join3(root, name))).filter((i) => existsSync(i));
+      const components = roots.flatMap((root) => names.map((name) => join4(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++;
@@ -569,28 +612,6 @@ var templateGlobalLayers = {
   }
 };
 
-// node/virtual/nav-controls.ts
-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 [
-        join4(root, "custom-nav-controls.vue"),
-        join4(root, "CustomNavControls.vue")
-      ];
-    }).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}
-import { h } from 'vue'
-export default {
-  render: () => [${render}],
-}`;
-  }
-};
-
 // node/virtual/layouts.ts
 import { objectMap } from "@antfu/utils";
 var templateLayouts = {
@@ -614,7 +635,7 @@ ${Object.entries(layouts).map(([k, v]) => `"${k}": ${v}`).join(",\n")}
 };
 
 // node/virtual/monaco-deps.ts
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 import { uniq as uniq2 } from "@antfu/utils";
 var templateMonacoRunDeps = {
   id: "/@slidev/monaco-run-deps",
@@ -622,7 +643,7 @@ var templateMonacoRunDeps = {
     if (!data.features.monaco)
       return "";
     const deps = uniq2(data.features.monaco.deps.concat(data.config.monacoTypesAdditionalPackages));
-    const importerPath = resolve(userRoot, "./snippets/__importer__.ts");
+    const importerPath = resolve2(userRoot, "./snippets/__importer__.ts");
     let result = "";
     for (let i = 0; i < deps.length; i++) {
       const specifier = deps[i];
@@ -643,9 +664,9 @@ var templateMonacoRunDeps = {
 
 // node/virtual/monaco-types.ts
 import { builtinModules } from "node:module";
-import { join as join5, resolve as resolve2 } from "node:path";
-import fg from "fast-glob";
+import { join as join5, resolve as resolve3 } from "node:path";
 import { uniq as uniq3 } from "@antfu/utils";
+import fg from "fast-glob";
 var templateMonacoTypes = {
   id: "/@slidev/monaco-types",
   getContent: async ({ userRoot, data, utils }) => {
@@ -655,7 +676,7 @@ var templateMonacoTypes = {
     const files = await fg(["**/*.ts", "**/*.mts", "**/*.cts"], { cwd: typesRoot });
     let result = 'import { addFile } from "@slidev/client/setup/monaco.ts"\n';
     for (const file of files) {
-      const url = `${toAtFS(resolve2(typesRoot, file))}?monaco-types&raw`;
+      const url = `${toAtFS(resolve3(typesRoot, file))}?monaco-types&raw`;
       result += `addFile(() => import(${JSON.stringify(url)}), ${JSON.stringify(file)})
 `;
     }
@@ -688,15 +709,37 @@ var templateMonacoTypes = {
   }
 };
 
+// node/virtual/nav-controls.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join6 } 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")
+      ];
+    }).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}
+import { h } from 'vue'
+export default {
+  render: () => [${render}],
+}`;
+  }
+};
+
 // node/virtual/setups.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function createSetupTemplate(name) {
   return {
     id: `/@slidev/setups/${name}`,
     getContent({ roots }) {
       const setups = roots.flatMap((i) => {
-        const path4 = join6(i, "setup", name);
+        const path4 = join7(i, "setup", name);
         return [".ts", ".mts", ".js", ".mjs"].map((ext) => path4 + ext);
       }).filter((i) => existsSync3(i));
       const imports = [];
@@ -820,13 +863,13 @@ ${slides.join(",\n")}
 };
 
 // node/virtual/styles.ts
-import { join as join7 } from "node:path";
 import { existsSync as existsSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 var templateStyle = {
   id: "/@slidev/styles",
   async getContent({ data, clientRoot, roots }) {
     function resolveUrlOfClient(name) {
-      return toAtFS(join7(clientRoot, name));
+      return toAtFS(join8(clientRoot, name));
     }
     const imports = [
       `import "${resolveUrlOfClient("styles/vars.css")}"`,
@@ -837,11 +880,11 @@ var templateStyle = {
     ];
     for (const root of roots) {
       const styles = [
-        join7(root, "styles", "index.ts"),
-        join7(root, "styles", "index.js"),
-        join7(root, "styles", "index.css"),
-        join7(root, "styles.css"),
-        join7(root, "style.css")
+        join8(root, "styles", "index.ts"),
+        join8(root, "styles", "index.js"),
+        join8(root, "styles", "index.css"),
+        join8(root, "styles.css"),
+        join8(root, "style.css")
       ];
       for (const style of styles) {
         if (existsSync4(style)) {
@@ -917,290 +960,40 @@ var templates = [
   templateLegacyTitles
 ];
 
-// node/options.ts
-import path from "node:path";
-import { uniq as uniq5 } from "@antfu/utils";
-import Debug from "debug";
-import mm from "micromatch";
-import fg2 from "fast-glob";
-
-// node/parser.ts
-import * as parser from "@slidev/parser/fs";
-
-// node/integrations/themes.ts
-import { join as join8 } from "node:path";
-import fs from "fs-extra";
-import { satisfies } from "semver";
-
-// package.json
-var version = "0.49.29";
-
-// node/integrations/themes.ts
-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 (!fs.existsSync(path4))
-    return {};
-  const { slidev = {}, engines = {} } = await fs.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/vite/loaders.ts
+function renderNote(text = "") {
+  let clickCount = 0;
+  const html = sharedMd.render(
+    text.replace(/\[click(?::(\d+))?\]/gi, (_, count = 1) => {
+      clickCount += Number(count);
+      return `<span class="slidev-note-click-mark" data-clicks="${clickCount}"></span>`;
+    })
+  );
+  return html;
 }
-
-// node/integrations/addons.ts
-import { resolve as resolve3 } from "node:path";
-import fs2 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 fs2.readJSON(resolve3(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;
+function withRenderedNote(data) {
+  return {
+    ...data,
+    noteHTML: renderNote(data?.note)
+  };
 }
-
-// node/setups/shiki.ts
-import fs4 from "node:fs/promises";
-import { bundledLanguages, createHighlighter } from "shiki";
-
-// node/setups/load.ts
-import { resolve as resolve4 } from "node:path";
-import fs3 from "fs-extra";
-import { deepMergeWithArray } from "@antfu/utils";
-async function loadSetups(roots, filename, args, extraLoader) {
-  const returns = [];
-  for (const root of roots) {
-    const path4 = resolve4(root, "setup", filename);
-    if (fs3.existsSync(path4)) {
-      const { default: setup } = loadModule(path4);
-      const ret = await setup(...args);
-      if (ret)
-        returns.push(ret);
+function createSlidesLoader(options, serverOptions) {
+  const { data, mode, utils } = options;
+  const hmrSlidesIndexes = /* @__PURE__ */ new Set();
+  let server;
+  let skipHmr = null;
+  let sourceIds = resolveSourceIds(data);
+  function resolveSourceIds(data2) {
+    const ids = {
+      md: [],
+      frontmatter: []
+    };
+    for (const type of ["md", "frontmatter"]) {
+      for (let i = 0; i < data2.slides.length; i++) {
+        ids[type].push(`${data2.slides[i].source.filepath}__slidev_${i + 1}.${type}`);
+      }
     }
-    if (extraLoader)
-      returns.push(...extraLoader(root));
-  }
-  return returns;
-}
-
-// node/setups/shiki.ts
-var cachedRoots;
-var cachedShiki;
-async function setupShiki(roots) {
-  if (cachedRoots === roots)
-    return cachedShiki;
-  cachedShiki?.shiki.dispose();
-  const options = await loadSetups(
-    roots,
-    "shiki.ts",
-    [{
-      /** @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 fs4.readFile(path4, "utf-8"));
-      }
-    }]
-  );
-  const mergedOptions = Object.assign({}, ...options);
-  if ("theme" in mergedOptions && "themes" in mergedOptions)
-    delete mergedOptions.theme;
-  if (mergedOptions.theme && typeof mergedOptions.theme !== "string" && !mergedOptions.theme.name && !mergedOptions.theme.tokenColors) {
-    mergedOptions.themes = mergedOptions.theme;
-    delete mergedOptions.theme;
-  }
-  if (!mergedOptions.theme && !mergedOptions.themes) {
-    mergedOptions.themes = {
-      dark: "vitesse-dark",
-      light: "vitesse-light"
-    };
-  }
-  if (mergedOptions.themes)
-    mergedOptions.defaultColor = false;
-  const shiki = await createHighlighter({
-    ...mergedOptions,
-    langs: mergedOptions.langs ?? Object.keys(bundledLanguages),
-    themes: "themes" in mergedOptions ? Object.values(mergedOptions.themes) : [mergedOptions.theme]
-  });
-  cachedRoots = roots;
-  return cachedShiki = {
-    shiki,
-    shikiOptions: mergedOptions
-  };
-}
-
-// node/setups/indexHtml.ts
-import { existsSync as existsSync5, readFileSync } from "node:fs";
-import { join as join9 } from "node:path";
-import { slash as slash2 } from "@antfu/utils";
-import { white, yellow as yellow2 } from "kolorist";
-import { escapeHtml } from "markdown-it/lib/common/utils.mjs";
-function toAttrValue(unsafe) {
-  return JSON.stringify(escapeHtml(String(unsafe)));
-}
-function setupIndexHtml({ mode, entry, clientRoot, userRoot, roots, data }) {
-  let main = readFileSync(join9(clientRoot, "index.html"), "utf-8");
-  let head = "";
-  let body = "";
-  const { info, author, keywords } = data.headmatter;
-  head += [
-    `<meta name="slidev:version" content="${version}">`,
-    mode === "dev" && `<meta charset="slidev:entry" content="${slash2(entry)}">`,
-    `<link rel="icon" href="${data.config.favicon}">`,
-    `<title>${getSlideTitle(data)}</title>`,
-    info && `<meta name="description" content=${toAttrValue(info)}>`,
-    author && `<meta name="author" content=${toAttrValue(author)}>`,
-    keywords && `<meta name="keywords" content=${toAttrValue(Array.isArray(keywords) ? keywords.join(", ") : keywords)}>`
-  ].filter(Boolean).join("\n");
-  for (const root of roots) {
-    const path4 = join9(root, "index.html");
-    if (!existsSync5(path4))
-      continue;
-    const index = readFileSync(path4, "utf-8");
-    if (root === userRoot && index.includes("<!DOCTYPE")) {
-      console.error(yellow2(`[Slidev] Ignored provided index.html with doctype declaration. (${white(path4)})`));
-      console.error(yellow2("This file may be generated by Slidev, please remove it from your project."));
-      continue;
-    }
-    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(join9(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
-  return main;
-}
-
-// node/options.ts
-var debug = Debug("slidev:options");
-async function resolveOptions(entryOptions, mode) {
-  const entry = await resolveEntry(entryOptions.entry);
-  const rootsInfo = await getRoots(entry);
-  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
-  let themeRaw = entryOptions.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, entryOptions.entry);
-  const addonRoots = await resolveAddons(config.addons);
-  const roots = uniq5([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
-  debug({
-    ...rootsInfo,
-    ...entryOptions,
-    config,
-    mode,
-    entry,
-    themeRaw,
-    theme,
-    themeRoots,
-    addonRoots,
-    roots
-  });
-  const data = {
-    ...loaded,
-    config,
-    themeMeta
-  };
-  const resolved = {
-    ...rootsInfo,
-    ...entryOptions,
-    data,
-    mode,
-    entry,
-    themeRaw,
-    theme,
-    themeRoots,
-    addonRoots,
-    roots
-  };
-  return {
-    ...resolved,
-    utils: await createDataUtils(resolved)
-  };
-}
-async function createDataUtils(resolved) {
-  const monacoTypesIgnorePackagesMatches = (resolved.data.config.monacoTypesIgnorePackages || []).map((i) => mm.matcher(i));
-  let _layouts_cache_time = 0;
-  let _layouts_cache = {};
-  return {
-    ...await setupShiki(resolved.roots),
-    indexHtml: setupIndexHtml(resolved),
-    iconsResolvePath: [resolved.clientRoot, ...resolved.roots].reverse(),
-    isMonacoTypesIgnored: (pkg) => monacoTypesIgnorePackagesMatches.some((i) => i(pkg)),
-    getLayouts: () => {
-      const now = Date.now();
-      if (now - _layouts_cache_time < 2e3)
-        return _layouts_cache;
-      const layouts = {};
-      for (const root of [resolved.clientRoot, ...resolved.roots]) {
-        const layoutPaths = fg2.sync("layouts/**/*.{vue,ts}", {
-          cwd: root,
-          absolute: true,
-          suppressErrors: true
-        });
-        for (const layoutPath of layoutPaths) {
-          const layoutName = path.basename(layoutPath).replace(/\.\w+$/, "");
-          layouts[layoutName] = layoutPath;
-        }
-      }
-      _layouts_cache_time = now;
-      _layouts_cache = layouts;
-      return layouts;
-    }
-  };
-}
-
-// node/vite/loaders.ts
-function renderNote(text = "") {
-  let clickCount = 0;
-  const html = sharedMd.render(
-    text.replace(/\[click(?::(\d+))?\]/gi, (_, count = 1) => {
-      clickCount += Number(count);
-      return `<span class="slidev-note-click-mark" data-clicks="${clickCount}"></span>`;
-    })
-  );
-  return html;
-}
-function withRenderedNote(data) {
-  return {
-    ...data,
-    noteHTML: renderNote(data?.note)
-  };
-}
-function createSlidesLoader(options, serverOptions) {
-  const hmrSlidesIndexes = /* @__PURE__ */ new Set();
-  let server;
-  let skipHmr = null;
-  const { data, mode, utils } = options;
-  function getSourceId(index, type) {
-    return `${data.slides[index].source.filepath}__slidev_${index + 1}.${type}`;
+    return ids;
   }
   function updateServerWatcher() {
     if (!server)
@@ -1258,11 +1051,11 @@ function createSlidesLoader(options, serverOptions) {
               fileContent
             };
             server?.moduleGraph.invalidateModule(
-              server.moduleGraph.getModuleById(getSourceId(idx, "md"))
+              server.moduleGraph.getModuleById(sourceIds.md[idx])
             );
             if (body.frontmatter) {
               server?.moduleGraph.invalidateModule(
-                server.moduleGraph.getModuleById(getSourceId(idx, "frontmatter"))
+                server.moduleGraph.getModuleById(sourceIds.frontmatter[idx])
               );
             }
           }
@@ -1290,9 +1083,19 @@ function createSlidesLoader(options, serverOptions) {
         return [];
       }
       const moduleIds = /* @__PURE__ */ new Set();
+      const newSourceIds = resolveSourceIds(newData);
+      for (const type of ["md", "frontmatter"]) {
+        const old = sourceIds[type];
+        const newIds = newSourceIds[type];
+        for (let i = 0; i < newIds.length; i++) {
+          if (old[i] !== newIds[i]) {
+            moduleIds.add(`${VIRTUAL_SLIDE_PREFIX}${i + 1}/${type}`);
+          }
+        }
+      }
+      sourceIds = newSourceIds;
       if (data.slides.length !== newData.slides.length) {
         moduleIds.add(templateSlides.id);
-        range(newData.slides.length).map((i) => hmrSlidesIndexes.add(i));
       }
       if (!equal(data.headmatter.defaults, newData.headmatter.defaults)) {
         moduleIds.add(templateSlides.id);
@@ -1336,8 +1139,8 @@ function createSlidesLoader(options, serverOptions) {
       if (hmrSlidesIndexes.size > 0)
         moduleIds.add(templateTitleRendererMd.id);
       const vueModules = Array.from(hmrSlidesIndexes).flatMap((idx) => {
-        const frontmatter = ctx.server.moduleGraph.getModuleById(getSourceId(idx, "frontmatter"));
-        const main = ctx.server.moduleGraph.getModuleById(getSourceId(idx, "md"));
+        const frontmatter = ctx.server.moduleGraph.getModuleById(sourceIds.frontmatter[idx]);
+        const main = ctx.server.moduleGraph.getModuleById(sourceIds.md[idx]);
         const styles = main ? [...main.clientImportedModules].find((m) => m.id?.includes(`&type=style`)) : void 0;
         return [
           frontmatter,
@@ -1374,7 +1177,7 @@ function createSlidesLoader(options, serverOptions) {
       if (matchFacade) {
         const [, no, type] = matchFacade;
         const idx = +no - 1;
-        const sourceId = JSON.stringify(getSourceId(idx, type));
+        const sourceId = JSON.stringify(sourceIds[type][idx]);
         return [
           `export * from ${sourceId}`,
           `export { default } from ${sourceId}`
@@ -1453,503 +1256,175 @@ function createSlidesLoader(options, serverOptions) {
 }
 
 // node/vite/markdown.ts
-import Markdown from "unplugin-vue-markdown/vite";
 import MagicString from "magic-string-stack";
+import Markdown from "unplugin-vue-markdown/vite";
 
-// node/setups/transformers.ts
-async function setupTransformers(roots) {
-  const returns = await loadSetups(roots, "transformers.ts", []);
-  const result = {
-    pre: [],
-    preCodeblock: [],
-    postCodeblock: [],
-    post: []
+// ../../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;
+(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.1.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(md, options = { enabled: false, label: false, lineNumber: false }) {
+  md.core.ruler.after("inline", "task-lists", (state) => processToken(state, options));
+  md.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}/>`;
+  };
+  md.renderer.rules.taskListItemLabel_close = () => {
+    return "</label>";
+  };
+  md.renderer.rules.taskListItemLabel_open = (tokens) => {
+    const token = tokens[0];
+    const id = token.attrGet("id");
+    return `<label for="${id}">`;
   };
-  for (const r of [...returns].reverse()) {
-    if (r.pre)
-      result.pre.push(...r.pre);
-    if (r.preCodeblock)
-      result.preCodeblock.push(...r.preCodeblock);
-  }
-  for (const r of returns) {
-    if (r.postCodeblock)
-      result.postCodeblock.push(...r.postCodeblock);
-    if (r.post)
-      result.post.push(...r.post);
-  }
-  return result;
 }
-
-// node/syntax/transform/code-wrapper.ts
-var reCodeBlock = /^```([\w'-]+)?\s*(?:\{([\w*,|-]+)\}\s*?(\{[^}]*\})?([^\r\n]*))?\r?\n(\S[\s\S]*?)^```$/gm;
-function transformCodeWrapper(ctx) {
-  ctx.s.replace(
-    reCodeBlock,
-    (full, lang = "", rangeStr = "", options = "", attrs = "", code) => {
-      const ranges = normalizeRangeStr(rangeStr);
-      code = code.trimEnd();
-      options = options.trim() || "{}";
-      return `
-<CodeBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>
-
-\`\`\`${lang}${attrs}
-${code}
-\`\`\`
-
-</CodeBlockWrapper>`;
+function processToken(state, options) {
+  const allTokens = state.tokens;
+  for (let i = 2; i < allTokens.length; i++) {
+    if (!isTodoItem(allTokens, i)) {
+      continue;
     }
-  );
-}
-
-// node/syntax/transform/in-page-css.ts
-function transformPageCSS(ctx) {
-  const codeBlocks = getCodeBlocks(ctx.s.original);
-  ctx.s.replace(
-    /(\n<style[^>]*>)([\s\S]+?)(<\/style>)/g,
-    (full, start, css, end, index) => {
-      if (codeBlocks.isInsideCodeblocks(index))
-        return full;
-      if (!start.includes("scoped"))
-        start = start.replace("<style", "<style scoped");
-      return `${start}
-${css}${end}`;
+    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;
 }
-
-// node/syntax/transform/katex-wrapper.ts
-function transformKaTexWrapper(ctx) {
-  ctx.s.replace(
-    /^\$\$(?:\s*\{([\w*,|-]+)\}\s*?(?:(\{[^}]*\})\s*?)?)?\n(\S[\s\S]*?)^\$\$/gm,
-    (full, rangeStr = "", options = "", code) => {
-      const ranges = !rangeStr.trim() ? [] : rangeStr.trim().split(/\|/g).map((i) => i.trim());
-      code = code.trimEnd();
-      options = options.trim() || "{}";
-      return `<KaTexBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>
-
-$$
-${code}
-$$
-</KaTexBlockWrapper>
-`;
+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;
 }
-
-// node/syntax/transform/magic-move.ts
-import { codeToKeyedTokens } from "shiki-magic-move/core";
-import lz from "lz-string";
-var reMagicMoveBlock = /^````(?:md|markdown) magic-move *(\{[^}]*\})?([^ \n]*)\n([\s\S]+?)^````$/gm;
-function parseLineNumbersOption(options) {
-  return /lines: *true/.test(options) ? true : /lines: *false/.test(options) ? false : void 0;
+function isTodoItem(tokens, index) {
+  return isInline(tokens[index]) && isParagraph(tokens[index - 1]) && isListItem(tokens[index - 2]) && startsWithTodoMarkdown(tokens[index]);
 }
-function transformMagicMove(ctx) {
-  ctx.s.replace(
-    reMagicMoveBlock,
-    (full, options = "{}", _attrs = "", body) => {
-      const matches = Array.from(body.matchAll(reCodeBlock));
-      if (!matches.length)
-        throw new Error("Magic Move block must contain at least one code block");
-      const defaultLineNumbers = parseLineNumbersOption(options) ?? ctx.options.data.config.lineNumbers;
-      const ranges = matches.map((i) => normalizeRangeStr(i[2]));
-      const steps = matches.map((i) => {
-        const lineNumbers = parseLineNumbersOption(i[3]) ?? defaultLineNumbers;
-        return codeToKeyedTokens(ctx.options.utils.shiki, i[5].trimEnd(), {
-          ...ctx.options.utils.shikiOptions,
-          lang: i[1]
-        }, lineNumbers);
-      });
-      const compressed = lz.compressToBase64(JSON.stringify(steps));
-      return `<ShikiMagicMove v-bind="${options}" steps-lz="${compressed}" :step-ranges='${JSON.stringify(ranges)}' />`;
-    }
-  );
+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());
+  }
 }
-
-// node/syntax/transform/mermaid.ts
-import lz2 from "lz-string";
-function transformMermaid(ctx) {
-  ctx.s.replace(
-    /^```mermaid *(\{[^\n]*\})?\n([\s\S]+?)\n```/gm,
-    (full, options = "", code = "") => {
-      code = code.trim();
-      options = options.trim() || "{}";
-      const encoded = lz2.compressToBase64(code);
-      return `<Mermaid code-lz="${encoded}" v-bind="${options}" />`;
-    }
-  );
+function generateIdForToken(token) {
+  if (token.map) {
+    return `task-item-${token.map[0]}`;
+  } else {
+    return `task-item-${Math.ceil(Math.random() * (1e4 * 1e3) - 1e3)}`;
+  }
 }
-
-// node/syntax/transform/monaco.ts
-import lz3 from "lz-string";
-function transformMonaco(ctx) {
-  const enabled = ctx.options.data.config.monaco === true || ctx.options.data.config.monaco === ctx.options.mode;
+function createCheckboxToken(token, enabled, id) {
+  const checkbox = new Token("taskListItemCheckbox", "", 0);
   if (!enabled) {
-    ctx.s.replace(/\{monaco([\w:,-]*)\}/g, "");
-    return;
+    checkbox.attrSet("disabled", "true");
   }
-  ctx.s.replace(
-    /^```(\w+) *\{monaco-diff\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^~~~ *\n([\s\S]+?)^```/gm,
-    (full, lang = "ts", options = "{}", code, diff) => {
-      lang = lang.trim();
-      options = options.trim() || "{}";
-      const encoded = lz3.compressToBase64(code);
-      const encodedDiff = lz3.compressToBase64(diff);
-      return `<Monaco code-lz="${encoded}" diff-lz="${encodedDiff}" lang="${lang}" v-bind="${options}" />`;
-    }
-  );
-  ctx.s.replace(
-    /^```(\w+) *\{monaco\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
-    (full, lang = "ts", options = "{}", code) => {
-      lang = lang.trim();
-      options = options.trim() || "{}";
-      const encoded = lz3.compressToBase64(code);
-      return `<Monaco code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
-    }
-  );
-  ctx.s.replace(
-    /^```(\w+) *\{monaco-run\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
-    (full, lang = "ts", options = "{}", code) => {
-      lang = lang.trim();
-      options = options.trim() || "{}";
-      const encoded = lz3.compressToBase64(code);
-      return `<Monaco runnable code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
-    }
-  );
+  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/syntax/transform/plant-uml.ts
-import { encode as encodePlantUml } from "plantuml-encoder";
-function transformPlantUml(ctx) {
-  const server = ctx.options.data.config.plantUmlServer;
-  ctx.s.replace(
-    /^```plantuml[^\n{}]*(\{[^}\n]*\})?\n([\s\S]+?)\n```/gm,
-    (full, options = "", content = "") => {
-      const code = encodePlantUml(content.trim());
-      options = options.trim() || "{}";
-      return `<PlantUml :code="'${code}'" :server="'${server}'" v-bind="${options}" />`;
+// node/syntax/markdown-it/index.ts
+import MarkdownItFootnote from "markdown-it-footnote";
+import MarkdownItMdc from "markdown-it-mdc";
+
+// node/setups/load.ts
+import { resolve as resolve4 } from "node:path";
+import { deepMergeWithArray } from "@antfu/utils";
+import fs3 from "fs-extra";
+async function loadSetups(roots, filename, args, extraLoader) {
+  const returns = [];
+  for (const root of roots) {
+    const path4 = resolve4(root, "setup", filename);
+    if (fs3.existsSync(path4)) {
+      const { default: setup } = await loadModule(path4);
+      const ret = await setup(...args);
+      if (ret)
+        returns.push(ret);
     }
-  );
+    if (extraLoader)
+      returns.push(...await extraLoader(root));
+  }
+  return returns;
 }
 
-// node/syntax/transform/slot-sugar.ts
-function transformSlotSugar(ctx) {
-  const linesWithNewline = ctx.s.original.split(/(\r?\n)/g);
-  const codeBlocks = getCodeBlocks(ctx.s.original);
-  const lines = [];
-  for (let i = 0; i < linesWithNewline.length; i += 2) {
-    const line = linesWithNewline[i];
-    const newline = linesWithNewline[i + 1] || "";
-    lines.push(line + newline);
-  }
-  let prevSlot = false;
-  let offset = 0;
-  lines.forEach((line) => {
-    const start = offset;
-    offset += line.length;
-    if (codeBlocks.isInsideCodeblocks(offset))
-      return;
-    const match = line.match(/^::\s*([\w.\-:]+)\s*::(\s*)$/);
-    if (match) {
-      ctx.s.overwrite(start, offset - match[2].length, `${prevSlot ? "\n\n</template>\n" : "\n"}<template v-slot:${match[1]}="slotProps">
-`);
-      prevSlot = true;
-    }
-  });
-  if (prevSlot)
-    ctx.s.append("\n\n</template>");
+// node/setups/katex.ts
+async function setupKatex(roots) {
+  const options = await loadSetups(roots, "katex.ts", []);
+  return Object.assign(
+    { strict: false },
+    ...options
+  );
 }
 
-// node/syntax/transform/snippet.ts
-import path3 from "node:path";
-import lz4 from "lz-string";
-import fs6 from "fs-extra";
-import { slash as slash3 } from "@antfu/utils";
-
-// node/vite/monacoWrite.ts
-import fs5 from "node:fs/promises";
-import path2 from "node:path";
-var monacoWriterWhitelist = /* @__PURE__ */ new Set();
-function createMonacoWriterPlugin({ userRoot }) {
-  return {
-    name: "slidev:monaco-write",
-    apply: "serve",
-    configureServer(server) {
-      server.ws.on("connection", (socket) => {
-        socket.on("message", async (data) => {
-          let json;
-          try {
-            json = JSON.parse(data.toString());
-          } catch {
-            return;
-          }
-          if (json.type === "custom" && json.event === "slidev:monaco-write") {
-            const { file, content } = json.data;
-            if (!monacoWriterWhitelist.has(file)) {
-              console.error(`[Slidev] Unauthorized file write: ${file}`);
-              return;
-            }
-            const filepath = path2.join(userRoot, file);
-            console.log("[Slidev] Writing file:", filepath);
-            await fs5.writeFile(filepath, content, "utf-8");
-          }
-        });
-      });
-    }
-  };
-}
-
-// node/syntax/transform/snippet.ts
-function dedent(text) {
-  const lines = text.split("\n");
-  const minIndentLength = lines.reduce((acc, line) => {
-    for (let i = 0; i < line.length; i++) {
-      if (line[i] !== " " && line[i] !== "	")
-        return Math.min(i, acc);
-    }
-    return acc;
-  }, Number.POSITIVE_INFINITY);
-  if (minIndentLength < Number.POSITIVE_INFINITY)
-    return lines.map((x) => x.slice(minIndentLength)).join("\n");
-  return text;
-}
-function testLine(line, regexp, regionName, end = false) {
-  const [full, tag, name] = regexp.exec(line.trim()) || [];
-  return full && tag && name === regionName && tag.match(end ? /^[Ee]nd ?[rR]egion$/ : /^[rR]egion$/);
-}
-function findRegion(lines, regionName) {
-  const regionRegexps = [
-    /^\/\/ ?#?((?:end)?region) ([\w*-]+)$/,
-    // javascript, typescript, java
-    /^\/\* ?#((?:end)?region) ([\w*-]+) ?\*\/$/,
-    // css, less, scss
-    /^#pragma ((?:end)?region) ([\w*-]+)$/,
-    // C, C++
-    /^<!-- #?((?:end)?region) ([\w*-]+) -->$/,
-    // HTML, markdown
-    /^#(End Region) ([\w*-]+)$/,
-    // Visual Basic
-    /^::#(endregion) ([\w*-]+)$/,
-    // Bat
-    /^# ?((?:end)?region) ([\w*-]+)$/
-    // C#, PHP, Powershell, Python, perl & misc
-  ];
-  let regexp = null;
-  let start = -1;
-  for (const [lineId, line] of lines.entries()) {
-    if (regexp === null) {
-      for (const reg of regionRegexps) {
-        if (testLine(line, reg, regionName)) {
-          start = lineId + 1;
-          regexp = reg;
-          break;
-        }
-      }
-    } else if (testLine(line, regexp, regionName, true)) {
-      return { start, end: lineId, regexp };
-    }
-  }
-  return null;
-}
-function transformSnippet({ s, slide, options }) {
-  const watchFiles = options.data.watchFiles;
-  const dir = path3.dirname(slide.source?.filepath ?? options.entry ?? options.userRoot);
-  s.replace(
-    // 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(
-        /^@\//.test(filepath) ? path3.resolve(options.userRoot, filepath.slice(2)) : path3.resolve(dir, filepath)
-      );
-      watchFiles[src] ??= /* @__PURE__ */ new Set();
-      watchFiles[src].add(slide.index);
-      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 = fs6.readFileSync(src, "utf8");
-      if (regionName) {
-        const lines = content.split(/\r?\n/);
-        const region = findRegion(lines, regionName.slice(1));
-        if (region) {
-          content = dedent(
-            lines.slice(region.start, region.end).filter((line) => !region.regexp.test(line.trim())).join("\n")
-          );
-        }
-      }
-      meta = meta.trim();
-      lang = lang.trim();
-      lang = lang || path3.extname(filepath).slice(1);
-      if (meta.match(/^\{monaco-write\}/)) {
-        monacoWriterWhitelist.add(filepath);
-        lang = lang.trim();
-        meta = meta.replace(/^\{monaco-write\}/, "").trim() || "{}";
-        const encoded = lz4.compressToBase64(content);
-        return `<Monaco writable=${JSON.stringify(filepath)} code-lz="${encoded}" lang="${lang}" v-bind="${meta}" />`;
-      }
-      return `\`\`\`${lang} ${meta}
-${content}
-\`\`\``;
-    }
-  );
-}
-
-// node/syntax/transform/index.ts
-async function getMarkdownTransformers(options) {
-  const extras = await setupTransformers(options.roots);
-  return [
-    ...extras.pre,
-    transformSnippet,
-    options.data.config.highlighter === "shiki" && transformMagicMove,
-    ...extras.preCodeblock,
-    transformMermaid,
-    transformPlantUml,
-    options.data.features.monaco && transformMonaco,
-    ...extras.postCodeblock,
-    transformCodeWrapper,
-    options.data.features.katex && transformKaTexWrapper,
-    transformPageCSS,
-    transformSlotSugar,
-    ...extras.post
-  ];
-}
-
-// ../../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;
-(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.1.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(md, options = { enabled: false, label: false, lineNumber: false }) {
-  md.core.ruler.after("inline", "task-lists", (state) => processToken(state, options));
-  md.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}/>`;
-  };
-  md.renderer.rules.taskListItemLabel_close = () => {
-    return "</label>";
-  };
-  md.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/syntax/markdown-it/index.ts
-import MarkdownItMdc from "markdown-it-mdc";
-import MarkdownItFootnote from "markdown-it-footnote";
-
-// node/setups/katex.ts
-async function setupKatex(roots) {
-  const options = await loadSetups(roots, "katex.ts", []);
-  return Object.assign(
-    { strict: false },
-    ...options
-  );
-}
+// node/syntax/markdown-it/markdown-it-escape-code.ts
+function MarkdownItEscapeInlineCode(md) {
+  const codeInline = md.renderer.rules.code_inline;
+  md.renderer.rules.code_inline = (tokens, idx, options, env, self) => {
+    const result = codeInline(tokens, idx, options, env, self);
+    return result.replace(/^<code/, "<code v-pre");
+  };
+}
 
 // node/syntax/markdown-it/markdown-it-katex.ts
 import katex from "katex";
@@ -2096,11 +1571,69 @@ function MarkdownItKatex(md, options) {
   md.renderer.rules.math_block = blockRenderer;
 }
 
-// node/syntax/markdown-it/markdown-it-v-drag.ts
-import { SourceMapConsumer } from "source-map-js";
-var dragComponentRegex = /<(v-?drag-?\w*)([\s>])/i;
-var dragDirectiveRegex = /(?<![</\w])v-drag(=".*?")?/i;
-function MarkdownItVDrag(md, markdownTransformMap) {
+// node/syntax/markdown-it/markdown-it-shiki.ts
+import { isTruthy } from "@antfu/utils";
+import { fromHighlighter } from "@shikijs/markdown-it/core";
+
+// node/syntax/transform/utils.ts
+function normalizeRangeStr(rangeStr = "") {
+  return !rangeStr.trim() ? [] : rangeStr.trim().split(/\|/g).map((i) => i.trim());
+}
+function getCodeBlocks(md) {
+  const codeblocks = Array.from(md.matchAll(/^```[\s\S]*?^```/gm)).map((m) => {
+    const start = m.index;
+    const end = m.index + m[0].length;
+    const startLine = md.slice(0, start).match(/\n/g)?.length || 0;
+    const endLine = md.slice(0, end).match(/\n/g)?.length || 0;
+    return [start, end, startLine, endLine];
+  });
+  return {
+    codeblocks,
+    isInsideCodeblocks(idx) {
+      return codeblocks.some(([s, e]) => s <= idx && idx <= e);
+    },
+    isLineInsideCodeblocks(line) {
+      return codeblocks.some(([, , s, e]) => s <= line && line <= e);
+    }
+  };
+}
+function escapeVueInCode(md) {
+  return md.replace(/\{\{/g, "&lbrace;&lbrace;");
+}
+
+// node/syntax/markdown-it/markdown-it-shiki.ts
+async function MarkdownItShiki({ data: { config }, mode, utils }) {
+  const transformers = [
+    ...utils.shikiOptions.transformers || [],
+    (config.twoslash === true || config.twoslash === mode) && (await import("@shikijs/vitepress-twoslash")).transformerTwoslash({
+      explicitTrigger: true,
+      twoslashOptions: {
+        handbookOptions: {
+          noErrorValidation: true
+        }
+      }
+    }),
+    {
+      pre(pre) {
+        this.addClassToHast(pre, "slidev-code");
+        delete pre.properties.tabindex;
+      },
+      postprocess(code) {
+        return escapeVueInCode(code);
+      }
+    }
+  ].filter(isTruthy);
+  return fromHighlighter(utils.shiki, {
+    ...utils.shikiOptions,
+    transformers
+  });
+}
+
+// node/syntax/markdown-it/markdown-it-v-drag.ts
+import { SourceMapConsumer } from "source-map-js";
+var dragComponentRegex = /<(v-?drag-?\w*)([\s>])/i;
+var dragDirectiveRegex = /(?<![</\w])v-drag(=".*?")?/i;
+function MarkdownItVDrag(md, markdownTransformMap) {
   const visited = /* @__PURE__ */ new WeakSet();
   const sourceMapConsumers = /* @__PURE__ */ new WeakMap();
   function getSourceMapConsumer(id) {
@@ -2153,54 +1686,11 @@ function MarkdownItVDrag(md, markdownTransformMap) {
   };
 }
 
-// node/syntax/markdown-it/markdown-it-shiki.ts
-import { isTruthy } from "@antfu/utils";
-import { fromHighlighter } from "@shikijs/markdown-it/core";
-async function MarkdownItShiki({ data: { config }, mode, utils }) {
-  const transformers = [
-    ...utils.shikiOptions.transformers || [],
-    (config.twoslash === true || config.twoslash === mode) && (await import("@shikijs/vitepress-twoslash")).transformerTwoslash({
-      explicitTrigger: true,
-      twoslashOptions: {
-        handbookOptions: {
-          noErrorValidation: true
-        }
-      }
-    }),
-    {
-      pre(pre) {
-        this.addClassToHast(pre, "slidev-code");
-        delete pre.properties.tabindex;
-      },
-      postprocess(code) {
-        return escapeVueInCode(code);
-      }
-    }
-  ].filter(isTruthy);
-  return fromHighlighter(utils.shiki, {
-    ...utils.shikiOptions,
-    transformers
-  });
-}
-
-// node/syntax/markdown-it/markdown-it-escape-code.ts
-function MarkdownItEscapeInlineCode(md) {
-  const codeInline = md.renderer.rules.code_inline;
-  md.renderer.rules.code_inline = (tokens, idx, options, env, self) => {
-    const result = codeInline(tokens, idx, options, env, self);
-    return result.replace(/^<code/, "<code v-pre");
-  };
-}
-
 // node/syntax/markdown-it/index.ts
 async function useMarkdownItPlugins(md, options, markdownTransformMap) {
   const { roots, data: { features, config } } = options;
   if (config.highlighter === "shiki") {
     md.use(await MarkdownItShiki(options));
-  } else {
-    console.warn("[Slidev] Highlighter: Prism highlighter is deprecated, and will be removed in v0.50. Refer to https://github.com/slidevjs/slidev/issues/1390");
-    const { default: MarkdownItPrism } = await import("./markdown-it-prism-P475G4NP.js");
-    md.use(MarkdownItPrism);
   }
   md.use(MarkdownItLink);
   md.use(MarkdownItEscapeInlineCode);
@@ -2213,6 +1703,366 @@ async function useMarkdownItPlugins(md, options, markdownTransformMap) {
     md.use(MarkdownItMdc);
 }
 
+// node/setups/transformers.ts
+async function setupTransformers(roots) {
+  const returns = await loadSetups(roots, "transformers.ts", []);
+  const result = {
+    pre: [],
+    preCodeblock: [],
+    postCodeblock: [],
+    post: []
+  };
+  for (const r of [...returns].reverse()) {
+    if (r.pre)
+      result.pre.push(...r.pre);
+    if (r.preCodeblock)
+      result.preCodeblock.push(...r.preCodeblock);
+  }
+  for (const r of returns) {
+    if (r.postCodeblock)
+      result.postCodeblock.push(...r.postCodeblock);
+    if (r.post)
+      result.post.push(...r.post);
+  }
+  return result;
+}
+
+// node/syntax/transform/code-wrapper.ts
+var reCodeBlock = /^```([\w'-]+)?\s*(?:\{([\w*,|-]+)\}\s*?(\{[^}]*\})?([^\r\n]*))?\r?\n([ \t]*\S[\s\S]*?)^```$/gm;
+function transformCodeWrapper(ctx) {
+  ctx.s.replace(
+    reCodeBlock,
+    (full, lang = "", rangeStr = "", options = "", attrs = "", code) => {
+      const ranges = normalizeRangeStr(rangeStr);
+      code = code.trimEnd();
+      options = options.trim() || "{}";
+      return `
+<CodeBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>
+
+\`\`\`${lang}${attrs}
+${code}
+\`\`\`
+
+</CodeBlockWrapper>`;
+    }
+  );
+}
+
+// node/syntax/transform/in-page-css.ts
+function transformPageCSS(ctx) {
+  const codeBlocks = getCodeBlocks(ctx.s.original);
+  ctx.s.replace(
+    /(\n<style[^>]*>)([\s\S]+?)(<\/style>)/g,
+    (full, start, css, end, index) => {
+      if (codeBlocks.isInsideCodeblocks(index))
+        return full;
+      if (!start.includes("scoped"))
+        start = start.replace("<style", "<style scoped");
+      return `${start}
+${css}${end}`;
+    }
+  );
+}
+
+// node/syntax/transform/katex-wrapper.ts
+function transformKaTexWrapper(ctx) {
+  ctx.s.replace(
+    /^\$\$(?:\s*\{([\w*,|-]+)\}\s*?(?:(\{[^}]*\})\s*?)?)?\n(\S[\s\S]*?)^\$\$/gm,
+    (full, rangeStr = "", options = "", code) => {
+      const ranges = !rangeStr.trim() ? [] : rangeStr.trim().split(/\|/g).map((i) => i.trim());
+      code = code.trimEnd();
+      options = options.trim() || "{}";
+      return `<KaTexBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>
+
+$$
+${code}
+$$
+</KaTexBlockWrapper>
+`;
+    }
+  );
+}
+
+// node/syntax/transform/magic-move.ts
+import lz from "lz-string";
+import { codeToKeyedTokens } from "shiki-magic-move/core";
+var reMagicMoveBlock = /^````(?:md|markdown) magic-move *(\{[^}]*\})?([^ \n]*)\n([\s\S]+?)^````$/gm;
+function parseLineNumbersOption(options) {
+  return /lines: *true/.test(options) ? true : /lines: *false/.test(options) ? false : void 0;
+}
+function transformMagicMove(ctx) {
+  ctx.s.replace(
+    reMagicMoveBlock,
+    (full, options = "{}", _attrs = "", body) => {
+      const matches = Array.from(body.matchAll(reCodeBlock));
+      if (!matches.length)
+        throw new Error("Magic Move block must contain at least one code block");
+      const defaultLineNumbers = parseLineNumbersOption(options) ?? ctx.options.data.config.lineNumbers;
+      const ranges = matches.map((i) => normalizeRangeStr(i[2]));
+      const steps = matches.map((i) => {
+        const lineNumbers = parseLineNumbersOption(i[3]) ?? defaultLineNumbers;
+        return codeToKeyedTokens(ctx.options.utils.shiki, i[5].trimEnd(), {
+          ...ctx.options.utils.shikiOptions,
+          lang: i[1]
+        }, lineNumbers);
+      });
+      const compressed = lz.compressToBase64(JSON.stringify(steps));
+      return `<ShikiMagicMove v-bind="${options}" steps-lz="${compressed}" :step-ranges='${JSON.stringify(ranges)}' />`;
+    }
+  );
+}
+
+// node/syntax/transform/mermaid.ts
+import lz2 from "lz-string";
+function transformMermaid(ctx) {
+  ctx.s.replace(
+    /^```mermaid *(\{[^\n]*\})?\n([\s\S]+?)\n```/gm,
+    (full, options = "", code = "") => {
+      code = code.trim();
+      options = options.trim() || "{}";
+      const encoded = lz2.compressToBase64(code);
+      return `<Mermaid code-lz="${encoded}" v-bind="${options}" />`;
+    }
+  );
+}
+
+// node/syntax/transform/monaco.ts
+import lz3 from "lz-string";
+function transformMonaco(ctx) {
+  const enabled = ctx.options.data.config.monaco === true || ctx.options.data.config.monaco === ctx.options.mode;
+  if (!enabled) {
+    ctx.s.replace(/\{monaco([\w:,-]*)\}/g, "");
+    return;
+  }
+  ctx.s.replace(
+    /^```(\w+) *\{monaco-diff\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^~~~ *\n([\s\S]+?)^```/gm,
+    (full, lang = "ts", options = "{}", code, diff) => {
+      lang = lang.trim();
+      options = options.trim() || "{}";
+      const encoded = lz3.compressToBase64(code);
+      const encodedDiff = lz3.compressToBase64(diff);
+      return `<Monaco code-lz="${encoded}" diff-lz="${encodedDiff}" lang="${lang}" v-bind="${options}" />`;
+    }
+  );
+  ctx.s.replace(
+    /^```(\w+) *\{monaco\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
+    (full, lang = "ts", options = "{}", code) => {
+      lang = lang.trim();
+      options = options.trim() || "{}";
+      const encoded = lz3.compressToBase64(code);
+      return `<Monaco code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
+    }
+  );
+  ctx.s.replace(
+    /^```(\w+) *\{monaco-run\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
+    (full, lang = "ts", options = "{}", code) => {
+      lang = lang.trim();
+      options = options.trim() || "{}";
+      const encoded = lz3.compressToBase64(code);
+      return `<Monaco runnable code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
+    }
+  );
+}
+
+// node/syntax/transform/plant-uml.ts
+import { encode as encodePlantUml } from "plantuml-encoder";
+function transformPlantUml(ctx) {
+  const server = ctx.options.data.config.plantUmlServer;
+  ctx.s.replace(
+    /^```plantuml[^\n{}]*(\{[^}\n]*\})?\n([\s\S]+?)\n```/gm,
+    (full, options = "", content = "") => {
+      const code = encodePlantUml(content.trim());
+      options = options.trim() || "{}";
+      return `<PlantUml :code="'${code}'" :server="'${server}'" v-bind="${options}" />`;
+    }
+  );
+}
+
+// node/syntax/transform/slot-sugar.ts
+function transformSlotSugar(ctx) {
+  const linesWithNewline = ctx.s.original.split(/(\r?\n)/g);
+  const codeBlocks = getCodeBlocks(ctx.s.original);
+  const lines = [];
+  for (let i = 0; i < linesWithNewline.length; i += 2) {
+    const line = linesWithNewline[i];
+    const newline = linesWithNewline[i + 1] || "";
+    lines.push(line + newline);
+  }
+  let prevSlot = false;
+  let offset = 0;
+  lines.forEach((line) => {
+    const start = offset;
+    offset += line.length;
+    if (codeBlocks.isInsideCodeblocks(offset))
+      return;
+    const match = line.match(/^::\s*([\w.\-:]+)\s*::(\s*)$/);
+    if (match) {
+      ctx.s.overwrite(start, offset - match[2].length, `${prevSlot ? "\n\n</template>\n" : "\n"}<template v-slot:${match[1]}="slotProps">
+`);
+      prevSlot = true;
+    }
+  });
+  if (prevSlot)
+    ctx.s.append("\n\n</template>");
+}
+
+// node/syntax/transform/snippet.ts
+import path2 from "node:path";
+import { slash as slash2 } from "@antfu/utils";
+import fs5 from "fs-extra";
+import lz4 from "lz-string";
+
+// node/vite/monacoWrite.ts
+import fs4 from "node:fs/promises";
+import path from "node:path";
+var monacoWriterWhitelist = /* @__PURE__ */ new Set();
+function createMonacoWriterPlugin({ userRoot }) {
+  return {
+    name: "slidev:monaco-write",
+    apply: "serve",
+    configureServer(server) {
+      server.ws.on("connection", (socket) => {
+        socket.on("message", async (data) => {
+          let json;
+          try {
+            json = JSON.parse(data.toString());
+          } catch {
+            return;
+          }
+          if (json.type === "custom" && json.event === "slidev:monaco-write") {
+            const { file, content } = json.data;
+            if (!monacoWriterWhitelist.has(file)) {
+              console.error(`[Slidev] Unauthorized file write: ${file}`);
+              return;
+            }
+            const filepath = path.join(userRoot, file);
+            console.log("[Slidev] Writing file:", filepath);
+            await fs4.writeFile(filepath, content, "utf-8");
+          }
+        });
+      });
+    }
+  };
+}
+
+// node/syntax/transform/snippet.ts
+function dedent(text) {
+  const lines = text.split("\n");
+  const minIndentLength = lines.reduce((acc, line) => {
+    for (let i = 0; i < line.length; i++) {
+      if (line[i] !== " " && line[i] !== "	")
+        return Math.min(i, acc);
+    }
+    return acc;
+  }, Number.POSITIVE_INFINITY);
+  if (minIndentLength < Number.POSITIVE_INFINITY)
+    return lines.map((x) => x.slice(minIndentLength)).join("\n");
+  return text;
+}
+function findRegion(lines, regionName) {
+  const regionRegexps = [
+    // javascript, typescript, java
+    [/^\/\/ ?#?region ([\w*-]+)$/, /^\/\/ ?#?endregion/],
+    // css, less, scss
+    [/^\/\* ?#region ([\w*-]+) ?\*\/$/, /^\/\* ?#endregion[\s\w*-]*\*\/$/],
+    // C, C++
+    [/^#pragma region ([\w*-]+)$/, /^#pragma endregion/],
+    // HTML, markdown
+    [/^<!-- #?region ([\w*-]+) -->$/, /^<!-- #?region[\s\w*-]*-->$/],
+    // Visual Basic
+    [/^#Region ([\w*-]+)$/, /^#End Region/],
+    // Bat
+    [/^::#region ([\w*-]+)$/, /^::#endregion/],
+    // C#, PHP, Powershell, Python, perl & misc
+    [/^# ?region ([\w*-]+)$/, /^# ?endregion/]
+  ];
+  let endReg = null;
+  let start = -1;
+  for (const [lineId, line] of lines.entries()) {
+    if (endReg === null) {
+      for (const [startReg, end] of regionRegexps) {
+        const match = line.trim().match(startReg);
+        if (match && match[1] === regionName) {
+          start = lineId + 1;
+          endReg = end;
+          break;
+        }
+      }
+    } else if (endReg.test(line.trim())) {
+      return {
+        start,
+        end: lineId,
+        regexp: endReg
+      };
+    }
+  }
+  return null;
+}
+var reMonacoWrite = /^\{monaco-write\}/;
+function transformSnippet({ s, slide, options }) {
+  const watchFiles = options.data.watchFiles;
+  const dir = path2.dirname(slide.source?.filepath ?? options.entry ?? options.userRoot);
+  s.replace(
+    // eslint-disable-next-line regexp/no-super-linear-backtracking
+    /^<<<\s*(\S.*?)(#[\w-]+)?\s*(?:\s(\S+?))?\s*(\{.*)?$/gm,
+    (full, filepath = "", regionName = "", lang = "", meta = "") => {
+      const src = slash2(
+        /^@\//.test(filepath) ? path2.resolve(options.userRoot, filepath.slice(2)) : path2.resolve(dir, filepath)
+      );
+      meta = meta.trim();
+      lang = lang.trim();
+      lang = lang || path2.extname(filepath).slice(1);
+      const isAFile = fs5.statSync(src).isFile();
+      if (!fs5.existsSync(src) || !isAFile) {
+        throw new Error(isAFile ? `Code snippet path not found: ${src}` : `Invalid code snippet option`);
+      }
+      let content = fs5.readFileSync(src, "utf8");
+      if (regionName) {
+        const lines = content.split(/\r?\n/);
+        const region = findRegion(lines, regionName.slice(1));
+        if (region) {
+          content = dedent(
+            lines.slice(region.start, region.end).filter((line) => !region.regexp.test(line.trim())).join("\n")
+          );
+        }
+      }
+      if (meta.match(reMonacoWrite)) {
+        monacoWriterWhitelist.add(filepath);
+        lang = lang.trim();
+        meta = meta.replace(reMonacoWrite, "").trim() || "{}";
+        const encoded = lz4.compressToBase64(content);
+        return `<Monaco writable=${JSON.stringify(filepath)} code-lz="${encoded}" lang="${lang}" v-bind="${meta}" />`;
+      } else {
+        watchFiles[src] ??= /* @__PURE__ */ new Set();
+        watchFiles[src].add(slide.index);
+      }
+      return `\`\`\`${lang} ${meta}
+${content}
+\`\`\``;
+    }
+  );
+}
+
+// node/syntax/transform/index.ts
+async function getMarkdownTransformers(options) {
+  const extras = await setupTransformers(options.roots);
+  return [
+    ...extras.pre,
+    transformSnippet,
+    options.data.config.highlighter === "shiki" && transformMagicMove,
+    ...extras.preCodeblock,
+    transformMermaid,
+    transformPlantUml,
+    options.data.features.monaco && transformMonaco,
+    ...extras.postCodeblock,
+    transformCodeWrapper,
+    options.data.features.katex && transformKaTexWrapper,
+    transformPageCSS,
+    transformSlotSugar,
+    ...extras.post
+  ];
+}
+
 // node/vite/markdown.ts
 async function createMarkdownPlugin(options, { markdown: mdOptions }) {
   const markdownTransformMap = /* @__PURE__ */ new Map();
@@ -2265,10 +2115,10 @@ async function createMarkdownPlugin(options, { markdown: mdOptions }) {
 }
 
 // node/vite/monacoTypes.ts
-import fs7 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import { dirname, resolve as resolve5 } from "node:path";
-import { slash as slash4 } from "@antfu/utils";
-import fg3 from "fast-glob";
+import { slash as slash3 } from "@antfu/utils";
+import fg2 from "fast-glob";
 import { findDepPkgJsonPath } from "vitefu";
 function createMonacoTypesLoader({ userRoot, utils }) {
   return {
@@ -2289,8 +2139,8 @@ function createMonacoTypesLoader({ userRoot, utils }) {
         const pkgJsonPath = await findDepPkgJsonPath(pkg, importer);
         if (!pkgJsonPath)
           throw new Error(`Package "${pkg}" not found in "${importer}"`);
-        const root = slash4(dirname(pkgJsonPath));
-        const pkgJson = JSON.parse(await fs7.readFile(pkgJsonPath, "utf-8"));
+        const root = slash3(dirname(pkgJsonPath));
+        const pkgJson = JSON.parse(await fs6.readFile(pkgJsonPath, "utf-8"));
         let deps = Object.keys(pkgJson.dependencies ?? {});
         deps = deps.filter((pkg2) => !utils.isMonacoTypesIgnored(pkg2));
         return [
@@ -2302,7 +2152,7 @@ function createMonacoTypesLoader({ userRoot, utils }) {
         const query = new URLSearchParams(url.search);
         const root = query.get("root");
         const name = query.get("name");
-        const files = await fg3(
+        const files = await fg2(
           [
             "**/*.ts",
             "**/*.mts",
@@ -2350,9 +2200,9 @@ async function createRemoteAssetsPlugin({ data: { config }, mode }, pluginOption
 import ServerRef from "vite-plugin-vue-server-ref";
 
 // node/integrations/drawings.ts
-import { basename, dirname as dirname2, join as join10, resolve as resolve6 } from "node:path";
-import fs8 from "fs-extra";
-import fg4 from "fast-glob";
+import { basename, dirname as dirname2, join as join9, resolve as resolve6 } from "node:path";
+import fg3 from "fast-glob";
+import fs7 from "fs-extra";
 function resolveDrawingsDir(options) {
   return options.data.config.drawings.persist ? resolve6(
     dirname2(options.entry),
@@ -2361,9 +2211,9 @@ function resolveDrawingsDir(options) {
 }
 async function loadDrawings(options) {
   const dir = resolveDrawingsDir(options);
-  if (!dir || !fs8.existsSync(dir))
+  if (!dir || !fs7.existsSync(dir))
     return {};
-  const files = await fg4("*.svg", {
+  const files = await fg3("*.svg", {
     onlyFiles: true,
     cwd: dir,
     absolute: true,
@@ -2374,7 +2224,7 @@ async function loadDrawings(options) {
     const num = +basename(path4, ".svg");
     if (Number.isNaN(num))
       return;
-    const content = await fs8.readFile(path4, "utf8");
+    const content = await fs7.readFile(path4, "utf8");
     const lines = content.split(/\n/g);
     obj[num.toString()] = lines.slice(1, -1).join("\n");
   }));
@@ -2387,7 +2237,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 fs8.ensureDir(dir);
+  await fs7.ensureDir(dir);
   return Promise.all(
     Object.entries(drawing).map(async ([key, value]) => {
       if (!value)
@@ -2395,14 +2245,34 @@ async function writeDrawings(options, drawing) {
       const svg = `${SVG_HEAD}
 ${value}
 </svg>`;
-      await fs8.writeFile(join10(dir, `${key}.svg`), svg, "utf-8");
+      await fs7.writeFile(join9(dir, `${key}.svg`), svg, "utf-8");
     })
   );
 }
 
+// node/integrations/snapshots.ts
+import { dirname as dirname3, join as join10, resolve as resolve7 } from "node:path";
+import fs8 from "fs-extra";
+function resolveSnapshotsDir(options) {
+  return resolve7(dirname3(options.entry), ".slidev/snapshots");
+}
+async function loadSnapshots(options) {
+  const dir = resolveSnapshotsDir(options);
+  const file = join10(dir, "snapshots.json");
+  if (!dir || !fs8.existsSync(file))
+    return {};
+  return JSON.parse(await fs8.readFile(file, "utf8"));
+}
+async function writeSnapshots(options, data) {
+  const dir = resolveSnapshotsDir(options);
+  if (!dir)
+    return;
+  await fs8.ensureDir(dir);
+  await fs8.writeFile(join10(dir, "snapshots.json"), JSON.stringify(data, null, 2), "utf-8");
+}
+
 // node/vite/serverRef.ts
 async function createServerRefPlugin(options, pluginOptions) {
-  const drawingData = await loadDrawings(options);
   return ServerRef({
     debug: false,
     // process.env.NODE_ENV === 'development',
@@ -2412,37 +2282,56 @@ async function createServerRefPlugin(options, pluginOptions) {
         page: 0,
         clicks: 0
       },
-      drawings: drawingData,
+      drawings: await loadDrawings(options),
+      snapshots: await loadSnapshots(options),
       ...pluginOptions.serverRef?.state
     },
     onChanged(key, data, patch, timestamp) {
       pluginOptions.serverRef?.onChanged?.(key, data, patch, timestamp);
-      if (!options.data.config.drawings.persist)
-        return;
-      if (key === "drawings")
+      if (options.data.config.drawings.persist && key === "drawings")
         writeDrawings(options, patch ?? data);
+      if (key === "snapshots")
+        writeSnapshots(options, data);
     }
   });
 }
 
+// node/vite/staticCopy.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join11 } from "node:path";
+async function createStaticCopyPlugin({ themeRoots, addonRoots }, pluginOptions) {
+  const publicDirs = [...themeRoots, ...addonRoots].map((i) => join11(i, "public")).filter(existsSync5);
+  if (!publicDirs.length)
+    return;
+  const { viteStaticCopy } = await import("vite-plugin-static-copy");
+  return viteStaticCopy({
+    silent: true,
+    targets: publicDirs.map((dir) => ({
+      src: `${dir}/*`,
+      dest: "theme"
+    })),
+    ...pluginOptions.staticCopy
+  });
+}
+
 // node/vite/unocss.ts
 import UnoCSS from "unocss/vite";
 
 // node/setups/unocss.ts
-import { resolve as resolve7 } from "node:path";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync } from "node:fs";
+import { resolve as resolve8 } from "node:path";
 import { mergeConfigs, presetIcons } from "unocss";
 async function setupUnocss({ clientRoot, roots, data, utils }) {
-  function loadFileConfigs(root) {
-    return [
-      resolve7(root, "uno.config.ts"),
-      resolve7(root, "unocss.config.ts")
-    ].map((i) => {
+  async function loadFileConfigs(root) {
+    return (await Promise.all([
+      resolve8(root, "uno.config.ts"),
+      resolve8(root, "unocss.config.ts")
+    ].map(async (i) => {
       if (!existsSync6(i))
         return void 0;
-      const loaded = loadModule(i);
+      const loaded = await loadModule(i);
       return "default" in loaded ? loaded.default : loaded;
-    });
+    }))).filter((x) => !!x);
   }
   const configs = [
     {
@@ -2451,13 +2340,13 @@ async function setupUnocss({ clientRoot, roots, data, utils }) {
           collectionsNodeResolvePath: utils.iconsResolvePath,
           collections: {
             slidev: {
-              logo: () => readFileSync2(resolve7(clientRoot, "assets/logo.svg"), "utf-8")
+              logo: () => readFileSync(resolve8(clientRoot, "assets/logo.svg"), "utf-8")
             }
           }
         })
       ]
     },
-    ...loadFileConfigs(clientRoot),
+    ...await loadFileConfigs(clientRoot),
     ...await loadSetups(roots, "unocss.ts", [], loadFileConfigs)
   ].filter(Boolean);
   const config = mergeConfigs(configs);
@@ -2521,12 +2410,13 @@ async function createVuePlugin(_options, pluginOptions) {
     exclude: [],
     ...vueOptions,
     template: {
+      ...vueOptions?.template,
       compilerOptions: {
+        ...vueOptions?.template?.compilerOptions,
         isCustomElement(tag) {
           return customElements.has(tag) || vueOptions?.template?.compilerOptions?.isCustomElement?.(tag);
         }
-      },
-      ...vueOptions?.template
+      }
     }
   });
   const VueJsxPlugin = VueJsx(vuejsxOptions);
@@ -2536,26 +2426,8 @@ async function createVuePlugin(_options, pluginOptions) {
   ];
 }
 
-// node/vite/staticCopy.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join11 } from "node:path";
-async function createStaticCopyPlugin({ themeRoots, addonRoots }, pluginOptions) {
-  const publicDirs = [...themeRoots, ...addonRoots].map((i) => join11(i, "public")).filter(existsSync7);
-  if (!publicDirs.length)
-    return;
-  const { viteStaticCopy } = await import("vite-plugin-static-copy");
-  return viteStaticCopy({
-    silent: true,
-    targets: publicDirs.map((dir) => ({
-      src: `${dir}/*`,
-      dest: "theme"
-    })),
-    ...pluginOptions.staticCopy
-  });
-}
-
 // node/vite/index.ts
-async function ViteSlidevPlugin(options, pluginOptions = {}, serverOptions = {}) {
+function ViteSlidevPlugin(options, pluginOptions = {}, serverOptions = {}) {
   return Promise.all([
     createSlidesLoader(options, serverOptions),
     createMarkdownPlugin(options, pluginOptions),
@@ -2593,7 +2465,7 @@ async function resolveViteConfigs(options, baseConfig, overrideConfigs, command,
   };
   const files = options.roots.map((i) => join12(i, "vite.config.ts"));
   for (const file of files) {
-    if (!existsSync8(file))
+    if (!existsSync7(file))
       continue;
     const viteConfig = await loadConfigFromFile(configEnv, file);
     if (!viteConfig?.config)
@@ -2613,15 +2485,204 @@ async function resolveViteConfigs(options, baseConfig, overrideConfigs, command,
   return baseConfig;
 }
 
+// node/setups/indexHtml.ts
+function toAttrValue(unsafe) {
+  return JSON.stringify(escapeHtml(String(unsafe)));
+}
+function setupIndexHtml({ mode, entry, clientRoot, userRoot, roots, data }) {
+  let main = readFileSync2(join13(clientRoot, "index.html"), "utf-8");
+  let head = "";
+  let body = "";
+  const { info, author, keywords } = data.headmatter;
+  head += [
+    `<meta name="slidev:version" content="${version}">`,
+    mode === "dev" && `<meta charset="slidev:entry" content="${slash4(entry)}">`,
+    `<link rel="icon" href="${data.config.favicon}">`,
+    `<title>${getSlideTitle(data)}</title>`,
+    info && `<meta name="description" content=${toAttrValue(info)}>`,
+    author && `<meta name="author" content=${toAttrValue(author)}>`,
+    keywords && `<meta name="keywords" content=${toAttrValue(Array.isArray(keywords) ? keywords.join(", ") : keywords)}>`
+  ].filter(Boolean).join("\n");
+  for (const root of roots) {
+    const path4 = join13(root, "index.html");
+    if (!existsSync8(path4))
+      continue;
+    const index = readFileSync2(path4, "utf-8");
+    if (root === userRoot && index.includes("<!DOCTYPE")) {
+      console.error(yellow2(`[Slidev] Ignored provided index.html with doctype declaration. (${white(path4)})`));
+      console.error(yellow2("This file may be generated by Slidev, please remove it from your project."));
+      continue;
+    }
+    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">`;
+  if (data.headmatter.lang)
+    main = main.replace('<html lang="en">', `<html lang="${data.headmatter.lang}">`);
+  main = main.replace("__ENTRY__", toAtFS(join13(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
+  return main;
+}
+
+// node/setups/shiki.ts
+import fs9 from "node:fs/promises";
+import { bundledLanguages, createHighlighter } from "shiki";
+var cachedRoots;
+var cachedShiki;
+async function setupShiki(roots) {
+  if (cachedRoots === roots)
+    return cachedShiki;
+  cachedShiki?.shiki.dispose();
+  const options = await loadSetups(
+    roots,
+    "shiki.ts",
+    [{
+      /** @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 fs9.readFile(path4, "utf-8"));
+      }
+    }]
+  );
+  const mergedOptions = Object.assign({}, ...options);
+  if ("theme" in mergedOptions && "themes" in mergedOptions)
+    delete mergedOptions.theme;
+  if (mergedOptions.theme && typeof mergedOptions.theme !== "string" && !mergedOptions.theme.name && !mergedOptions.theme.tokenColors) {
+    mergedOptions.themes = mergedOptions.theme;
+    delete mergedOptions.theme;
+  }
+  if (!mergedOptions.theme && !mergedOptions.themes) {
+    mergedOptions.themes = {
+      dark: "vitesse-dark",
+      light: "vitesse-light"
+    };
+  }
+  if (mergedOptions.themes)
+    mergedOptions.defaultColor = false;
+  const shiki = await createHighlighter({
+    ...mergedOptions,
+    langs: mergedOptions.langs ?? Object.keys(bundledLanguages),
+    themes: "themes" in mergedOptions ? Object.values(mergedOptions.themes) : [mergedOptions.theme]
+  });
+  cachedRoots = roots;
+  return cachedShiki = {
+    shiki,
+    shikiOptions: mergedOptions
+  };
+}
+
+// node/options.ts
+var debug = Debug("slidev:options");
+async function resolveOptions(entryOptions, mode) {
+  const entry = await resolveEntry(entryOptions.entry);
+  const rootsInfo = await getRoots(entry);
+  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
+  let themeRaw = entryOptions.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, entryOptions.entry);
+  const addonRoots = await resolveAddons(config.addons);
+  const roots = uniq5([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
+  if (entryOptions.download)
+    config.download ||= entryOptions.download;
+  debug({
+    ...rootsInfo,
+    ...entryOptions,
+    config,
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots
+  });
+  const data = {
+    ...loaded,
+    config,
+    themeMeta
+  };
+  const resolved = {
+    ...rootsInfo,
+    ...entryOptions,
+    data,
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots
+  };
+  return {
+    ...resolved,
+    utils: await createDataUtils(resolved)
+  };
+}
+async function createDataUtils(resolved) {
+  const monacoTypesIgnorePackagesMatches = (resolved.data.config.monacoTypesIgnorePackages || []).map((i) => mm.matcher(i));
+  let _layouts_cache_time = 0;
+  let _layouts_cache = {};
+  return {
+    ...await setupShiki(resolved.roots),
+    indexHtml: setupIndexHtml(resolved),
+    define: getDefine(resolved),
+    iconsResolvePath: [resolved.clientRoot, ...resolved.roots].reverse(),
+    isMonacoTypesIgnored: (pkg) => monacoTypesIgnorePackagesMatches.some((i) => i(pkg)),
+    getLayouts: () => {
+      const now = Date.now();
+      if (now - _layouts_cache_time < 2e3)
+        return _layouts_cache;
+      const layouts = {};
+      for (const root of [resolved.clientRoot, ...resolved.roots]) {
+        const layoutPaths = fg4.sync("layouts/**/*.{vue,ts}", {
+          cwd: root,
+          absolute: true,
+          suppressErrors: true
+        });
+        for (const layoutPath of layoutPaths) {
+          const layoutName = path3.basename(layoutPath).replace(/\.\w+$/, "");
+          layouts[layoutName] = layoutPath;
+        }
+      }
+      _layouts_cache_time = now;
+      _layouts_cache = layouts;
+      return layouts;
+    }
+  };
+}
+function getDefine(options) {
+  return {
+    __DEV__: options.mode === "dev" ? "true" : "false",
+    __SLIDEV_CLIENT_ROOT__: JSON.stringify(toAtFS(options.clientRoot)),
+    __SLIDEV_HASH_ROUTE__: JSON.stringify(options.data.config.routerMode === "hash"),
+    __SLIDEV_FEATURE_DRAWINGS__: JSON.stringify(options.data.config.drawings.enabled === true || options.data.config.drawings.enabled === options.mode),
+    __SLIDEV_FEATURE_EDITOR__: JSON.stringify(options.mode === "dev" && options.data.config.editor !== false),
+    __SLIDEV_FEATURE_DRAWINGS_PERSIST__: JSON.stringify(!!options.data.config.drawings.persist === true),
+    __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"
+  };
+}
+
 export {
-  resolveViteConfigs,
-  parser,
   version,
+  resolveAddons,
   resolveTheme,
   getThemeMeta,
-  resolveAddons,
+  parser,
   loadSetups,
   resolveOptions,
   createDataUtils,
-  ViteSlidevPlugin
+  ViteSlidevPlugin,
+  resolveViteConfigs
 };